不会线程池？一篇文章教会你用它做订单批量创建

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 数据库相关依赖，根据实际情况选择 -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
publicclass ThreadPoolConfig {

    /**
     * 自定义订单处理线程池
     */
    @Bean(name = "orderTaskExecutor")
    public Executor orderTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池常驻的线程数量，默认情况下会一直存活
        executor.setCorePoolSize(8);
        // 最大线程数：线程池允许创建的最大线程数
        executor.setMaxPoolSize(16);
        // 队列容量：核心线程数满了之后，任务会存入队列等待执行
        executor.setQueueCapacity(1000);
        // 线程空闲时间：超过核心线程数的线程，空闲时间达到该值后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程名称前缀：方便日志排查问题
        executor.setThreadNamePrefix("order-batch-");
        // 拒绝策略：当队列满了且最大线程数已达上限时，如何处理新任务
        // CALLER_RUNS：由提交任务的主线程执行，避免任务丢失
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化线程池
        executor.initialize();
        return executor;
    }
}

// 订单实体类
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;

@Data
@TableName("t_order")
publicclass Order {
    @TableId(type = IdType.AUTO)
    private Long id;
    // 用户ID
    private Long userId;
    // 订单编号
    private String orderNo;
    // 商品ID
    private Long productId;
    // 订单金额
    private BigDecimal amount;
    // 订单状态：0-待支付 1-已支付
    private Integer status;
    // 创建时间
    private Date createTime;
}

// OrderMapper接口
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;

@Repository
public interface OrderMapper extends BaseMapper<Order> {
}

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.UUID;

@Service
publicclass OrderService {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 异步创建单个订单
     * @param userId 用户ID
     * @param productId 商品ID
     * @param amount 订单金额
     */
    @Async("orderTaskExecutor")
    public void createOrderAsync(Long userId, Long productId, BigDecimal amount) {
        try {
            Order order = new Order();
            order.setUserId(userId);
            order.setProductId(productId);
            order.setAmount(amount);
            order.setOrderNo(UUID.randomUUID().toString().replace("-", ""));
            order.setStatus(0);
            order.setCreateTime(new Date());
            // 插入数据库
            orderMapper.insert(order);
            // 模拟业务处理耗时（如调用库存服务、日志记录等）
            Thread.sleep(100);
        } catch (Exception e) {
            // 异常处理：记录日志、补偿机制等
            e.printStackTrace();
        }
    }

    /**
     * 批量创建订单入口
     * @param userId 用户ID
     * @param productIds 商品ID列表
     * @param amount 订单金额
     */
    public void batchCreateOrder(Long userId, List<Long> productIds, BigDecimal amount) {
        for (Long productId : productIds) {
            // 调用异步方法，提交到线程池处理
            createOrderAsync(userId, productId, amount);
        }
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class OrderBatchApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderBatchApplication.class, args);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.math.BigDecimal;
import java.util.List;

@RestController
@RequestMapping("/order")
publicclass OrderController {

    @Autowired
    private OrderService orderService;

    /**
     * 批量创建订单接口
     * @param userId 用户ID
     * @param productIds 商品ID列表（多个用逗号分隔）
     * @param amount 订单金额
     * @return 响应结果
     */
    @PostMapping("/batchCreate")
    public String batchCreateOrder(@RequestParam Long userId,
                                   @RequestParam List<Long> productIds,
                                   @RequestParam BigDecimal amount) {
        if (productIds.isEmpty()) {
            return"商品ID列表不能为空";
        }
        // 调用批量创建方法
        orderService.batchCreateOrder(userId, productIds, amount);
        return"批量订单创建任务已提交，正在处理中";
    }
}