CompletionService：Java并发工具包

Java并发编程利器：CompletionService实现原理解析

引言：为什么需要CompletionService？

在多线程编程中，我们常常需要提交一批任务并收集它们的结果。传统的做法是使用ExecutorService提交任务，获得Future对象集合，然后遍历这些Future，使用get()方法阻塞等待每个任务完成。这种方法存在一个明显的问题：任务完成的顺序与提交的顺序可能不一致，但我们必须按提交顺序等待。

假设我们提交了10个任务，第10个任务先完成，但我们必须等待前9个任务完成后才能获取第10个任务的结果。这种"队头阻塞"现象严重影响了程序的响应性。而CompletionService正是为解决这个问题而生！

CompletionService的核心思想

CompletionService的设计哲学是：任务完成的顺序就是结果可用的顺序。它将任务执行与结果消费解耦，让调用者能够按照任务完成的自然顺序处理结果，而不是按照任务提交的顺序。

基本用法对比

让我们先通过一个简单示例感受两者的差异：

 // 传统方式：按提交顺序获取结果
 List<Future<Integer>> futures = new ArrayList<>();
 for (int i = 0; i < 10; i++) {
     futures.add(executor.submit(new CallableTask(i)));
 }
 ​
 for (Future<Integer> future : futures) {
     Integer result = future.get(); // 阻塞，即使后面的任务先完成
     processResult(result);
 }
 ​
 // CompletionService方式：按完成顺序获取结果
 CompletionService<Integer> cs = new ExecutorCompletionService<>(executor);
 for (int i = 0; i < 10; i++) {
     cs.submit(new CallableTask(i));
 }
 ​
 for (int i = 0; i < 10; i++) {
     Integer result = cs.take().get(); // 总是获取最先完成的任务结果
     processResult(result);
 }

ExecutorCompletionService的架构剖析

核心组件

ExecutorCompletionService的实现基于三个核心组件：

1. Executor：实际执行任务的线程池

2. BlockingQueue<Future<V>>：存储已完成任务的结果队列

3. QueueingFuture ：扩展自FutureTask的内部类，是关键实现所在

类结构图

 public class ExecutorCompletionService<V> implements CompletionService<V> {
     private final Executor executor;
     private final BlockingQueue<Future<V>> completionQueue;
     
     // 核心内部类
     private class QueueingFuture extends FutureTask<Void> {
         private final Future<V> task;
         
         QueueingFuture(Future<V> task) {
             super(task, null);
             this.task = task;
         }
         
         // 关键钩子方法
         protected void done() { 
             completionQueue.add(task); 
         }
     }
 }

QueueingFuture：巧妙的桥接设计

QueueingFuture是整个CompletionService的灵魂所在。它是一个典型的装饰器模式（Decorator Pattern）应用。

FutureTask的done()方法揭秘

要理解QueueingFuture，首先需要了解FutureTask的done()方法。done()是FutureTask提供的一个保护性钩子方法（protected hook method），在任务完成时自动调用。

调用时机：

• 当任务正常完成（成功执行）

• 当任务被取消

• 当任务执行抛出异常

无论任务以何种方式结束，done()方法都会被调用。这就为我们提供了一个"通知点"，让我们能够在任务结束时执行自定义逻辑。

QueueingFuture的实现机制

 private class QueueingFuture extends FutureTask<Void> {
     private final Future<V> task;
     
     QueueingFuture(RunnableFuture<V> task) {
         super(task, null);  // 包装原始任务
         this.task = task;
     }
     
     @Override
     protected void done() {
         completionQueue.add(task);  // 任务完成时自动入队
     }
 }

这里的设计非常巧妙：

1. QueueingFuture包装了原始的RunnableFuture（通常是FutureTask）

2. 当包装的任务完成时，QueueingFuture的done()方法被调用

3. done()方法将原始任务（包含结果）放入完成队列

这个设计实现了关注点分离：

• 原始任务只负责执行和产生结果

• QueueingFuture负责结果收集的通知机制

• CompletionService负责结果的存储和消费

工作流程详解

任务提交流程

 public Future<V> submit(Callable<V> task) {
     if (task == null) throw new NullPointerException();
     RunnableFuture<V> f = newTaskFor(task);  // 创建FutureTask
     executor.execute(new QueueingFuture(f)); // 用QueueingFuture包装并提交
     return f;
 }

1. 创建标准的FutureTask来封装用户任务

2. 用QueueingFuture包装这个FutureTask

3. 将QueueingFuture提交给底层Executor执行

4. 返回原始的FutureTask给调用者（用于取消等操作）

结果获取流程

CompletionService提供了两种获取结果的方式：

 // 阻塞方式：等待下一个完成的任务
 public Future<V> take() throws InterruptedException {
     return completionQueue.take();
 }
 ​
 // 非阻塞方式：立即返回，没有则返回null
 public Future<V> poll() {
     return completionQueue.poll();
 }
 ​
 // 超时等待方式
 public Future<V> poll(long timeout, TimeUnit unit) 
     throws InterruptedException {
     return completionQueue.poll(timeout, unit);
 }

源码级的时序分析

让我们深入源码，追踪一个任务从提交到结果获取的完整生命周期：

 // 1. 用户提交任务
 completionService.submit(callable);
 ​
 // 2. ExecutorCompletionService内部
 public Future<V> submit(Callable<V> task) {
     RunnableFuture<V> f = newTaskFor(task);
     executor.execute(new QueueingFuture(f));
     return f;
 }
 ​
 // 3. QueueingFuture执行
 public void run() {
     // FutureTask的run方法
     // 执行用户定义的call()方法
     // 设置结果状态
     // 调用done()钩子方法
 }
 ​
 // 4. done()被调用
 protected void done() {
     completionQueue.add(task); // 关键步骤：结果入队
 }
 ​
 // 5. 用户获取结果
 Future<V> future = completionService.take();
 V result = future.get(); // 此时结果已就绪

实际应用场景

场景一：并行下载多个文件，按完成顺序处理

 public class ParallelDownloader {
     private final CompletionService<File> cs;
     
     public void downloadFiles(List<String> urls) {
         for (String url : urls) {
             cs.submit(() -> downloadFile(url));
         }
         
         for (int i = 0; i < urls.size(); i++) {
             try {
                 File file = cs.take().get();
                 processDownloadedFile(file); // 按完成顺序处理
             } catch (Exception e) {
                 handleError(e);
             }
         }
     }
 }

场景二：竞速查询多个数据源

 public class FastestSourceFinder {
     public String findFromFastest(List<DataSource> sources) {
         CompletionService<String> cs = new ExecutorCompletionService<>(
             Executors.newFixedThreadPool(sources.size()));
         
         for (DataSource source : sources) {
             cs.submit(source::query);
         }
         
         try {
             // 只取第一个完成的结果
             return cs.take().get();
         } catch (Exception e) {
             return fallbackResult();
         }
     }
 }

性能考量与最佳实践

1. 队列容量管理

默认使用LinkedBlockingQueue，无界队列可能导致内存问题。可以通过自定义队列控制容量：

BlockingQueue<Future<Result>> boundedQueue = 
    new LinkedBlockingQueue<>(100);
CompletionService<Result> cs = 
    new ExecutorCompletionService<>(executor, boundedQueue);

2. 异常处理策略

CompletionService不会吞没异常，异常会被包装在Future中：

Future<V> future = cs.take();
try {
    V result = future.get();
} catch (ExecutionException e) {
    Throwable cause = e.getCause(); // 获取真正的异常
    handleTaskException(cause);
}

3. 资源清理

确保在不再需要时关闭线程池：

ExecutorService executor = Executors.newFixedThreadPool(n);
CompletionService<V> cs = new ExecutorCompletionService<>(executor);

try {
    // 使用completionService
} finally {
    executor.shutdown();
}

与相关技术的比较

vs CompletionStage/CompletableFuture

CompletableFuture提供了更丰富的组合操作，而CompletionService更专注于"按完成顺序获取结果"这一特定场景：

特性	CompletionService	CompletableFuture
核心功能	按完成顺序收集结果	异步编程组合
链式操作	不支持	支持
异常处理	通过Future.get()	内置方法
组合能力	有限	强大
使用场景	批量任务结果收集	复杂异步流程

vs 普通ExecutorService

ExecutorService需要手动管理Future集合，而CompletionService自动管理结果队列：

 // ExecutorService方式需要手动同步
 List<Future<V>> futures = Collections.synchronizedList(new ArrayList<>());
 ​
 // CompletionService内部已处理并发安全

实现模式总结

ExecutorCompletionService展示了几种经典设计模式的组合：

1. 装饰器模式 ：QueueingFuture装饰原始的FutureTask

2. 观察者模式 ：通过done()钩子实现完成通知

3. 生产者-消费者模式：执行线程生产结果，消费线程从队列获取

这种设计的高明之处在于：

• 解耦：任务执行与结果收集分离

• 扩展性：通过钩子方法实现扩展，符合开闭原则

• 简洁性：用户接口简单直观，内部实现精巧

结语

CompletionService是Java并发工具包中一个被低估的利器。它通过QueueingFuture和done()钩子方法的巧妙结合，实现了任务完成顺序与结果获取顺序的解耦。理解其实现原理不仅有助于我们更好地使用这个工具，更能启发我们在设计异步系统时的思考：如何通过合理的抽象和钩子设计，构建松耦合、可扩展的并发组件。

在实际开发中，当遇到"批量异步任务处理"的场景时，不妨考虑使用CompletionService。它能让你的程序更高效、响应更快，同时保持代码的清晰和简洁。

---

以下是CompletionService工作原理的序列图：

以下是ExecutorCompletionService的类结构图：