Spring Boot中JDBC连接池耗尽与并发任务管理教程

spring:
  datasource:
    hikari:
      maximum-pool-size: 10 # 根据应用负载调整，默认值通常为10
      connection-timeout: 30000 # 客户端等待连接的最长时间（毫秒），默认30秒
      idle-timeout: 600000 # 连接在池中空闲的最长时间（毫秒），默认10分钟
      max-lifetime: 1800000 # 连接在池中的最长生命周期（毫秒），默认30分钟
      minimum-idle: 2 # 保持在池中的最小空闲连接数，默认与maximumPoolSize相同

@Transactional
public void processOrder(Order order) {
    orderDao.save(order); // 获取连接，开始事务
    // 大量复杂的业务计算，耗时10秒
    performHeavyCalculation(); 
    // 调用外部服务，耗时5秒
    callExternalService(); 
    orderDao.updateStatus(order.getId(), "PROCESSED"); // 提交事务，释放连接
}

public void processOrderWorkflow(Order order) {
    // 1. 保存订单（短事务）
    orderService.saveOrderInTransaction(order); 

    // 2. 执行耗时计算（不持有连接）
    HeavyCalculationResult result = performHeavyCalculation(order);

    // 3. 调用外部服务（不持有连接）
    ExternalServiceResponse response = callExternalService(result);

    // 4. 更新订单状态（短事务）
    orderService.updateOrderStatusInTransaction(order.getId(), response.getStatus());
}

@Transactional
public void saveOrderInTransaction(Order order) {
    orderDao.save(order);
}

@Transactional
public void updateOrderStatusInTransaction(Long orderId, String status) {
    orderDao.updateStatus(orderId, status);
}

// Controller
@RestController
public class TradeController {
    @Autowired
    private ITradeService tradeService;

    @GetMapping("/processTrade")
    public String processTrade() throws Exception {
        tradeService.service(); // 这可能在内部启动多个线程
        return "Trade processing initiated.";
    }
}

// ITradeService 接口和实现
public interface ITradeService extends Callable<Void> {
    void service();
}

@Service
public class TradeServiceImpl implements ITradeService {

    @Autowired
    private TradeDao tradeDao;
    @Autowired
    private Type1Dao type1Dao;
    @Autowired
    private Type2Dao type2Dao;
    @Autowired
    private Type3Dao type3Dao;

    @Autowired
    private ThreadPoolTaskExecutor taskExecutor; // 假设已配置

    @Override
    public void service() {
        // method1() to method4() might be sequential and potentially transactional
        // ...

        // method5(), method6(), method7() are independent and run in parallel
        List<Callable<Void>> tasks = new ArrayList<>();
        tasks.add(() -> {
            // This task will run in a separate thread.
            // If method5() is @Transactional, it will acquire its own connection.
            method5(); 
            return null;
        });
        tasks.add(() -> {
            method6();
            return null;
        });
        tasks.add(() -> {
            method7();
            return null;
        });

        try {
            // Submit tasks to the thread pool
            taskExecutor.invokeAll(tasks); // This will block until all tasks complete
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Parallel trade methods interrupted", e);
        }
    }

    // Example methods with potential @Transactional implications
    @Transactional(propagation = Propagation.REQUIRES_NEW) // Each parallel method gets its own transaction/connection
    public void method5() {
        // DB operations using type1Dao
        type1Dao.doSomething();
        // Potentially long-running non-DB logic here should be avoided
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method6() {
        // DB operations using type2Dao
        type2Dao.doSomethingElse();
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method7() {
        // DB operations using type3Dao
        type3Dao.doAnotherThing();
    }
}