SpringBoot中实现异步的六种方式

@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);
    }
}

@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() + " 正在生成报表");
                // 报表生成核心逻辑（数据查询、计算、导出等）
            });
        }
    }
}

@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() + " 所有前置校验完成，开始创建订单");
                    // 订单创建核心逻辑
                });
    }
}

/**
 * 订单创建事件
 */
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);
        // 事件处理逻辑（如：发送订单通知、更新库存、记录日志等）
    }
}

@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() + " 正在处理数据");
            // 数据处理核心逻辑
        });
    }
}

@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());
        // 周期性数据处理逻辑（如：统计昨日订单、清理无效数据、同步第三方数据等）
    }
}