SpringBoot中实现多线程六种方式大全_Java

spring boot 提供了非常丰富的多线程支持手段，从最简单的注解到虚拟线程（java 21+ / 25+ 时代的主流方向），可以满足从简单异步任务到高并发 io/cpu 密集型场景的各种需求。

下面列出目前（2026 年视角）最常用、最推荐的 6 种方式，并按推荐优先级排序（从最常用 → 最前沿）。

1. @async + @enableasync（最常用、最简单）

核心步骤：

启动类或配置类加 @enableasync
方法加 @async
（可选）自定义线程池 threadpooltaskexecutor

// 开启异步
@enableasync
@springbootapplication
public class application { ... }

// 异步方法
@service
public class mailservice {

    @async
    public void sendmail(string to, string content) {
        // 耗时操作
        log.info("发送邮件中... thread: {}", thread.currentthread().getname());
    }
}

自定义线程池（强烈推荐）：

@configuration
public class asyncconfig implements asyncconfigurer {

    @override
    public executor getasyncexecutor() {
        threadpooltaskexecutor executor = new threadpooltaskexecutor();
        executor.setcorepoolsize(8);
        executor.setmaxpoolsize(16);
        executor.setqueuecapacity(200);
        executor.setthreadnameprefix("async-mail-");
        // 拒绝策略（很重要！）
        executor.setrejectedexecutionhandler(new threadpoolexecutor.callerrunspolicy());
        executor.initialize();
        return executor;
    }

    @override
    public asyncuncaughtexceptionhandler getasyncuncaughtexceptionhandler() {
        return (ex, method, params) -> log.error("异步异常", ex);
    }
}

优点：零侵入、简单
缺点：无法获取返回值（需配合 completablefuture）

2. completablefuture + @async（有返回值 + 链式编排）

适用场景：需要异步结果、任务编排、并行聚合、超时控制

@service
public class userservice {

    @async
    public completablefuture<user> getuserbyid(long id) {
        // 模拟耗时
        thread.sleep(1000);
        return completablefuture.completedfuture(new user(id));
    }

    public completablefuture<list<user>> batchgetusers(list<long> ids) {
        list<completablefuture<user>> futures = ids.stream()
            .map(this::getuserbyid)
            .tolist();

        return completablefuture.allof(futures.toarray(new completablefuture[0]))
            .thenapply(v -> futures.stream().map(completablefuture::join).tolist());
    }
}

优点：强大组合能力、异常处理友好
缺点：代码稍复杂

3. threadpooltaskexecutor 手动提交任务（最灵活）

适用场景：需要精细控制线程池、批量任务、自定义拒绝策略

@autowired
private threadpooltaskexecutor executor;

public void processbatch(list<task> tasks) {
    list<completablefuture<void>> futures = new arraylist<>();
    for (task task : tasks) {
        completablefuture<void> future = completablefuture.runasync(task::execute, executor);
        futures.add(future);
    }
    completablefuture.allof(futures.toarray(new completablefuture[0])).join();
}

4. java 原生方式（executors / thread / runnable / callable）

适用场景：不依赖 spring 容器、测试、工具类、极简场景

// 方式1：直接 new thread（不推荐）
new thread(() -> dosomething()).start();

// 方式2：executors 工具类
executorservice executor = executors.newfixedthreadpool(10);
executor.submit(() -> dosomething());

注意：生产环境强烈不建议直接用 executors.newfixedthreadpool()，因为 oom 风险极大（无界队列）。

5. 虚拟线程（java 21+ / spring boot 3.2+ / 3.3+ 强烈推荐）

适用场景：高并发 io 密集型场景（接口调用、文件读写、数据库查询等）

开启方式（spring boot 3.2+）：

# application.yml
spring:
  threads:
    virtual:
      enabled: true

或代码方式：

@bean
public taskexecutor taskexecutor() {
    return executors.newvirtualthreadpertaskexecutor();
}

@async 也会自动使用虚拟线程（当启用后）

优点：线程创建成本极低、可创建数十万线程、极大提升吞吐量
缺点：cpu 密集型任务不适合（仍建议用固定线程池）

6. spring 定时任务 + 多线程（@scheduled + 线程池）

适用场景：定时批量处理、爬虫、清理任务

@configuration
@enablescheduling
@enableasync
public class scheduleconfig {

    @scheduled(cron = "0 */5 * * * ?")
    @async("batchexecutor")
    public void processbatchjob() {
        // 批量处理逻辑
    }

    @bean("batchexecutor")
    public threadpooltaskexecutor batchexecutor() {
        threadpooltaskexecutor executor = new threadpooltaskexecutor();
        executor.setcorepoolsize(4);
        executor.setmaxpoolsize(8);
        // ...
        return executor;
    }
}

优先级	方式	推荐场景	推荐指数
★★★★★	@async + 自定义线程池	99% 普通异步任务	最高
★★★★☆	completablefuture	需要结果、编排、并行聚合	很高
★★★★☆	虚拟线程（enabled=true）	高并发 io 密集型	强烈推荐
★★★☆☆	threadpooltaskexecutor 手动	精细控制、批量任务	常用
★★☆☆☆	java 原生 executors	非 spring 场景、测试	谨慎
★★☆☆☆	@scheduled + 多线程	定时批量处理	特定场景