java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > SpringBoot异步实现方式

SpringBoot中实现异步的六种方式

作者：彭于晏Yan

在SpringBoot开发中,合理运用多线程技术能显著提升系统吞吐量与响应速度,本文总结了6种在SpringBoot中实现多线程的技术方式,包括注解式异步、显式线程池、CompletableFuture、事件监听、JDK原生线程池和异步定时任务,每种方式都有其适用场景,需要的朋友可以参考下

在Spring Boot开发中，合理运用多线程技术能显著提升系统吞吐量与响应速度。

本文梳理了 6 种落地性极强的多线程实现方式，覆盖从「简单注解式异步」到「复杂多任务编排」的全场景，结合不同业务场景（高并发、系统解耦、周期性任务）和技术诉求（开发效率、精细控制、可观测性），可灵活选型；同时补充生产级避坑指南、线程池调优策略和监控方案，确保异步方案不仅 “能用”，更能 “稳定用、高效用”

1. @Async注解（开发首选）

基于AOP动态代理机制，实现方法级别的异步执行，无需手动管理线程生命周期。

特点：

适用场景：日志记录、邮件发送、短信通知等简单异步任务。

配置自定义线程池并开启异步支持：

@Configuration
@EnableAsync // 开启Spring异步支持
public class AsyncConfig {
    /**
     * 自定义异步线程池配置
     * @return 线程池执行器
     */
    @Bean("taskExecutor") // 自定义线程池名称，便于指定使用
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4); // 核心线程数，默认建议设置为CPU核心数
        executor.setMaxPoolSize(8); // 最大线程数，建议为核心线程数的2倍，应对突发高并发
        executor.setQueueCapacity(100); // 任务队列容量，缓冲待执行任务
        executor.setThreadNamePrefix("Async-"); // 线程名称前缀，便于日志排查
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略：主线程执行
        executor.initialize(); // 初始化线程池
        return executor;
    }
}

@Service
public class DemoService {

    @Async("taskExecutor") // 指定使用自定义的线程池
    public void sendEmail(String email) {
        System.out.println("线程:" + Thread.currentThread().getName() + "消息ID:" +" 正在发送邮件至:" + email);
    }
}

2. 显式使用线程池（精细控制）

@Service
public class DemoService {

    // 注入自定义线程池（对应AsyncConfig中配置的bean）
    @Resource(name = "taskExecutor")
    private ThreadPoolTaskExecutor executor;

    /**
     * 异步生成业务报表
     */
    public void generateReport() {
        for (int i = 0; i < 50; i++) {
            // 提交异步任务到线程池
            executor.execute(() -> {
                System.out.println("线程：" + Thread.currentThread().getName() + " 正在生成报表");
                // 报表生成核心逻辑（数据查询、计算、导出等）
            });
        }
    }
}

3. CompletableFuture（多任务编排）

@Service
public class DemoService {
    
    @Resource(name = "taskExecutor")
	private ThreadPoolTaskExecutor executor;

    /**
     * 异步检查库存
     * @return 库存是否充足（Future结果）
     */
    public CompletableFuture<Boolean> checkInventory() {
        // 异步执行库存检查逻辑
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("线程：" + Thread.currentThread().getName() + " 检查库存");
            return true; // 模拟库存充足
        },executor);
    }

    /**
     * 异步扣减余额
     * @return 余额扣减是否成功（Future结果）
     */
    public CompletableFuture<Boolean> deductBalance() {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("线程：" + Thread.currentThread().getName() + " 扣减余额");
            return true; // 模拟扣减成功
        },executor);
    }

    /**
     * 下单核心逻辑：并行执行库存检查+余额扣减，完成后执行后续操作
     */
    public void placeOrder() {
        // 并行执行多个异步任务
        CompletableFuture.allOf(checkInventory(), deductBalance())
                .thenRun(() -> { // 所有任务完成后执行
                    System.out.println("线程：" + Thread.currentThread().getName() + " 所有前置校验完成，开始创建订单");
                    // 订单创建核心逻辑
                });
    }
}

4. 事件监听+@Async（系统解耦）

/**
 * 订单创建事件
 */
public class OrderCreatedEvent extends ApplicationEvent {
    private Long orderId; // 订单ID

    /**
     * 构造函数
     * @param source 事件源（当前发布事件的对象）
     * @param orderId 订单ID
     */
    public OrderCreatedEvent(Object source, Long orderId) {
        super(source);
        this.orderId = orderId;
    }

    // getter
    public Long getOrderId() {
        return orderId;
    }
}

@Service
public class DemoService {

    // 注入Spring事件发布器
    @Resource
    private ApplicationEventPublisher publisher;

    /**
     * 创建订单（核心逻辑）
     */
    public void createOrder() {
        // 1. 执行创建订单的核心逻辑
        Long orderId = 123L; // 模拟生成订单ID
        System.out.println("主线程：创建订单，订单ID：" + orderId);

        // 2. 发布订单创建事件
        publisher.publishEvent(new OrderCreatedEvent(this, orderId));
    }
}

@Component
public class OrderListener {
    /**
     * 异步处理订单创建事件
     * @param event 订单创建事件
     */
    @Async("taskExecutor") // 异步处理，指定自定义线程池
    @EventListener // 监听OrderCreatedEvent事件
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        Long orderId = event.getOrderId();
        System.out.println("线程：" + Thread.currentThread().getName() + " 处理订单事件，订单ID：" + orderId);
        // 事件处理逻辑（如：发送订单通知、更新库存、记录日志等）
    }
}

5. JDK原生线程池（轻量使用）

@Service
public class DemoService {

    // 创建固定大小的JDK原生线程池（10个核心线程）
    private ExecutorService executor1 = Executors.newFixedThreadPool(10, r -> {
        Thread thread = new Thread(r);
        thread.setName("JdkAsync-"); // 线程名称前缀
        return thread;
    });

    /**
     * 异步处理数据
     */
    public void processData() {
        // 提交任务到线程池执行
        executor1.submit(() -> {
            System.out.println("线程：" + Thread.currentThread().getName() + " 正在处理数据");
            // 数据处理核心逻辑
        });
    }
}

6. 异步定时任务（周期性处理）

@Configuration
@EnableAsync // 开启异步支持
@EnableScheduling // 开启定时任务支持
public class ScheduledConfig {
    /**
     * 异步定时执行报表统计任务
     * fixedRate = 5000：每隔5秒执行一次（从上一次执行开始计时）
     */
    @Async("taskExecutor") // 异步执行，指定自定义线程池
    @Scheduled(fixedRate = 5000)
    public void reportJob() {
        System.out.println("线程：" + Thread.currentThread().getName() + " 执行定时报表统计，时间：" + System.currentTimeMillis());
        // 周期性数据处理逻辑（如：统计昨日订单、清理无效数据、同步第三方数据等）
    }
}

总结

实现方式适用场景复杂度开发效率性能风险点
@Async 注解简单异步任务（邮件、日志）低高中注解失效、异常未捕获
显式线程池高并发数据处理、精细线程控制高低高线程池参数不合理导致 OOM
CompletableFuture多任务编排、复杂业务流中中高默认线程池共享导致阻塞
事件监听 +@Async系统解耦、多异步操作触发中中中事件丢失、重复消费
JDK 原生线程池简单并发、临时性任务低中中未优雅关闭导致任务丢失
异步定时任务周期性数据处理低高中定时任务堆积、执行时间重叠

实践建议：

以上就是SpringBoot中实现异步的六种方式的详细内容，更多关于SpringBoot异步实现方式的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:
阅读全文