Java并发编程实战：三种线程池任务执行策略对比

Java并发编程实战：三种线程池任务执行策略对比

在Java并发编程中，合理使用线程池执行并发任务是提高系统性能的关键技术之一。本文将基于三个典型代码示例，分析不同的并发任务执行策略，帮助开发者根据实际场景选择最合适的实现方案。

一、线程池基础配置

无论是哪种执行策略，良好的线程池配置都是基础。三个示例中都采用了相似的线程池配置：

private final static ExecutorService executor = new ThreadPoolExecutor(
    Runtime.getRuntime().availableProcessors() * 8,  // 核心线程数
    Runtime.getRuntime().availableProcessors() * 8,  // 最大线程数
    0L, TimeUnit.MILLISECONDS,                     // 空闲线程存活时间
    new LinkedBlockingQueue<Runnable>(),           // 工作队列
    new CustomThreadFactory("executor"),           // 自定义线程工厂
    new ThreadPoolExecutor.AbortPolicy());         // 拒绝策略

配置要点解析：

1. 线程数设置：CPU核心数×8，适用于IO密集型任务（如数据库操作、网络请求）
2. 无界队列：LinkedBlockingQueue确保所有任务都能被接受，但可能导致内存溢出
3. 线程命名：自定义线程工厂便于问题排查
4. 拒绝策略：AbortPolicy在队列满时抛出异常，防止系统过载

二、同步执行策略：CountDownLatch实现

RuleSessionExecutor展示了使用CountDownLatch的同步执行方案：

public void execute(List<CustomerSession> rules) {
    final CountDownLatch lock = new CountDownLatch(rules.size());
    
    for (CustomerSession session : rules) {
        try {
            session.exec(); // 同步执行
        } catch (Throwable e) {
            // 异常处理
        } finally {
            lock.countDown();
        }
    }
    
    try {
        lock.await(50, TimeUnit.MILLISECONDS); // 超时等待
    } catch (InterruptedException e) {
        log.error("CountDownLatch error", e);
    }
}

适用场景：

• 需要严格保证所有任务执行完成
• 任务执行时间较短且可控
• 对执行结果有强一致性要求

优缺点分析：
✅ 实现简单直接
✅ 确保所有任务都被执行
❌ 实际上是串行执行，没有真正并发
❌ 超时控制不够精确（只控制等待时间而非执行时间）

三、异步执行策略：CompletableFuture实现

DataSourceExecutor展示了更高级的CompletableFuture方案：

public void execute(List<DataSource> dataSources) {
    List<CompletableFuture> futures = new ArrayList<>();
    long timeout = getConfiguredTimeout(); // 获取超时配置
    
    for (DataSource ds : dataSources) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            ds.execute(); 
        }, executor);
        futures.add(future);
    }
    
    CompletableFuture<Void> allFutures = CompletableFuture.allOf(
        futures.toArray(new CompletableFuture[0]));
    
    try {
        allFutures.get(timeout, TimeUnit.MILLISECONDS);
    } catch (Exception e) {
        // 处理各类异常
    }
}

优势特性：

1. 真正的异步执行：任务并行执行
2. 灵活的超时控制：可针对每个任务单独设置超时
3. 异常处理完善：区分中断、执行和超时异常
4. 结果组合：allOf方便聚合多个Future

适用场景：

• 需要真正并发执行的独立任务
• 各任务执行时间差异较大
• 需要精细化的超时控制

四、简单执行策略：基础线程池提交

第三种方案展示了最基本的线程池使用方式：

public void execute(List<Task> tasks) {
    tasks.forEach(t -> {
        executor.execute(() -> {
            try {
                log.info("task {} begin", t.getId());
                t.execute();
            } catch (Throwable e) {
                log.error("task error", e);
            } finally {
                log.info("task {} end", t.getId());
            }
        });
    });
}

适用情况：

• 不需要等待任务执行完成
• 不关心执行结果
• 简单的日志记录需求

典型应用：

• 异步日志记录
• 非关键的后台操作
• 事件通知等"触发后不管"场景

五、方案选型指南

维度	CountDownLatch方案	CompletableFuture方案	简单提交方案
真正并发	❌	✅	✅
执行等待	✅	✅	❌
超时控制	弱	强	无
异常处理	简单	完善	一般
实现复杂度	低	中	极低
任务间依赖	不支持	支持	不支持
执行顺序保证	顺序执行	无序	无序

选型建议：

1. 需要严格顺序执行 → CountDownLatch方案
2. 需要真正并发+超时控制 → CompletableFuture
3. 简单后台任务 → 直接提交方案

六、最佳实践建议

1. 线程池配置：

   • IO密集型：核心数×（2~8）
   • CPU密集型：核心数+1
   • 考虑使用有界队列+CallerRunsPolicy避免OOM

2. 异常处理：

   future.exceptionally(ex -> {
       log.error("Task failed", ex);
       return defaultResult;
   });
   

3. 超时设置：

   // 为每个任务单独设置超时
   CompletableFuture.supplyAsync(() -> task.execute(), executor)
       .orTimeout(100, TimeUnit.MILLISECONDS);
   

4. 监控增强：

   // 使用装饰器模式监控任务执行
   executor = new MonitoringExecutorWrapper(executor, metrics);
   

结语

Java并发编程提供了丰富的工具集，从基础的线程池提交到高级的CompletableFuture，开发者可以根据业务场景灵活选择。关键是要理解各种方案的适用场景和限制，避免"一刀切"的实现方式。在实际项目中，往往需要结合多种策略，才能构建出既高效又可靠的并发系统。

思考题：在你的项目中，哪种并发执行策略最常用？遇到过哪些并发问题？欢迎留言讨论！