深入解析与解决高并发下的线程池死锁问题

@Service
public class OrderService {

    @Autowired
    private StockService stockService;

    @Async("stockThreadPool")
    public void deductStockAfterPaymentSuccess(Order order) {
        stockService.deduct(order.getProductId(), order.getQuantity());
        // 更新订单状态等后续逻辑...
    }
}

@Entity
public class Product {
    @Id
    private Long id;
    private Integer stock;
    @Version
    private Long version;
    // getters and setters
}

@Service
public class StockService {

    @Transactional
    public boolean deduct(Long productId, Integer quantity) {
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new ResourceNotFoundException("Product not found"));
        
        if (product.getStock() < quantity) return false;
        
        int updatedStock = product.getStock() - quantity;
        product.setStock(updatedStock);
        
        try {
            product = productRepository.save(product);
        } catch (OptimisticLockException e) {
            // 处理乐观锁失败，通常重试或记录日志
            return false;
        }
        return true;
    }
}

@Configuration
public class ThreadPoolConfig {

    @Bean(name = "optimizedThreadPool")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数，根据CPU核心数和业务需求合理设定
        executor.setCorePoolSize(4 * Runtime.getRuntime().availableProcessors());
        // 最大线程数，防止线程数无限制增长导致资源耗尽
        executor.setMaxPoolSize(executor.getCorePoolSize() * 2);
        // 队列大小，当核心线程都被占用时，新任务将在队列中等待
        executor.setQueueCapacity(500);
        // 拒绝策略，这里采用CallerRunsPolicy，让调用者线程执行任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 设置线程空闲时间，超过该时间的空闲线程将被终止
        executor.setKeepAliveSeconds(60);
        // 线程名前缀，方便日志追踪
        executor.setThreadNamePrefix("OptimizedThreadPool-");
        // 初始化线程池
        executor.initialize();
        return executor;
    }
}

@Service
public class OrderService {

    @Autowired
    @Qualifier("optimizedThreadPool") // 使用自定义线程池
    private ThreadPoolTaskExecutor executor;

    public void deductStockAfterPaymentSuccess(Order order) {
        executor.execute(() -> {
            stockService.deduct(order.getProductId(), order.getQuantity());
            // 更新订单状态等后续逻辑...
        });
    }
}

@Service
public class OrderService {

    // ... 其他代码 ...

    public void deductStockWithRetry(Order order) {
        int retryCount = 0;
        final int maxRetries = 3; // 最大重试次数
        while (retryCount <= maxRetries) {
            try {
                Future<Boolean> resultFuture = executor.submit(() -> stockService.deduct(order.getProductId(), order.getQuantity()));
                // 使用自定义的超时时间，5秒
                if (resultFuture.get(5, TimeUnit.SECONDS)) {
                    System.out.println("库存扣减成功");
                    break; // 成功则跳出循环
                } else {
                    throw new RuntimeException("库存不足，扣减失败");
                }
            } catch (TimeoutException e) {
                System.out.println("库存扣减操作超时，准备重试...");
            } catch (InterruptedException | ExecutionException e) {
                System.out.println("操作异常，准备重试... " + e.getMessage());
            }

            retryCount++;
            if (retryCount > maxRetries) {
                System.out.println("重试次数已达上限，操作失败");
                break;
            } else {
                try {
                    Thread.sleep(1000); // 退避策略，重试前等待一秒
                } catch (InterruptedException ignored) {}
            }
        }
    }
}