1、简单介绍



我们在并发编程中，目前大部分做法都是将任务添加到线程池中，并拿到Future对象，将其添加到集合中，等所有任务都添加到线程池后，在通过遍历Future集合，调用future.get()来获取每个任务的结果，这样可以使得先添加到线程池的任务先等待其完成，但是并不能保证第一个添加到线程池的任务就是第一个执行完成的，所以会出现这种情况，后面添加到线程池的任务已经完成了，但是还必须要等待第一个任务执行完成并处理结果后才能处理接下来的任务。

如果想要不管添加到线程池的任务的顺序，先完成的任务先进行处理，那么就需要用到ExecutorCompletionService这个工具了。



2、源码解析



ExecutorCompletionService实现了CompletionService接口。CompletionService接种有有以下方法。

1public interface CompletionService<V> {
2    // 提交任务
3    Future<V> submit(Callable<V> task);
4    // 提交任务
5    Future<V> submit(Runnable task, V result);
6    // 获取任务结果，带抛出异常
7    Future<V> take() throws InterruptedException;
8    // 获取任务结果
9    Future<V> poll();
10    // 获取任务结果，带超时
11    Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;
12}



可以看到接口中的方法非常简单，只有提交任务以及获取任务结果两类方法。

我们再看下实现类ExecutorCompletionService中的代码。

1public class ExecutorCompletionService<V> implements CompletionService<V> {
2    private final Executor executor;
3    private final AbstractExecutorService aes;
4    private final BlockingQueue<Future<V>> completionQueue;
5
6    /**
7     * FutureTask的子类，重写FutureTask完成后的done方法
8     */
9    private class QueueingFuture extends FutureTask<Void> {
10        QueueingFuture(RunnableFuture<V> task) {
11            super(task, null);
12            this.task = task;
13        }
14	// task任务执行完成后将任务放到队列中
15        protected void done() { completionQueue.add(task); }
16        private final Future<V> task;
17    }
18
19    private RunnableFuture<V> newTaskFor(Callable<V> task) {
20        if (aes == null)
21            return new FutureTask<V>(task);
22        else
23            return aes.newTaskFor(task);
24    }
25
26    private RunnableFuture<V> newTaskFor(Runnable task, V result) {
27        if (aes == null)
28            return new FutureTask<V>(task, result);
29        else
30            return aes.newTaskFor(task, result);
31    }
32
33    /**
34     * 构造方法，传入一个线程池，创建一个队列
35     */
36    public ExecutorCompletionService(Executor executor) {
37        if (executor == null)
38            throw new NullPointerException();
39        this.executor = executor;
40        this.aes = (executor instanceof AbstractExecutorService) ?
41            (AbstractExecutorService) executor : null;
42        this.completionQueue = new LinkedBlockingQueue<Future<V>>();
43    }
44
45    /**
46     * 构造方法，传入线程池和队列
47     */
48    public ExecutorCompletionService(Executor executor,
49                                     BlockingQueue<Future<V>> completionQueue) {
50        if (executor == null || completionQueue == null)
51            throw new NullPointerException();
52        this.executor = executor;
53        this.aes = (executor instanceof AbstractExecutorService) ?
54            (AbstractExecutorService) executor : null;
55        this.completionQueue = completionQueue;
56    }
57
58    // 提交一个task任务，最终将任务封装成QueueingFuture并由指定的线程池执行
59    public Future<V> submit(Callable<V> task) {
60        if (task == null) throw new NullPointerException();
61        RunnableFuture<V> f = newTaskFor(task);
62        executor.execute(new QueueingFuture(f));
63        return f;
64    }
65
66    // 提交一个task任务，最终将任务封装成QueueingFuture并由指定的线程池执行
67    public Future<V> submit(Runnable task, V result) {
68        if (task == null) throw new NullPointerException();
69        RunnableFuture<V> f = newTaskFor(task, result);
70        executor.execute(new QueueingFuture(f));
71        return f;
72    }
73
74    // 从队列中获取执行完成的RunnableFuture对象，take方法会阻塞直到有数据
75    public Future<V> take() throws InterruptedException {
76        return completionQueue.take();
77    }
78
79    // 从队列中获取执行完成的RunnableFuture对象
80    public Future<V> poll() {
81        return completionQueue.poll();
82    }
83
84    // 从队列中获取执行完成的RunnableFuture对象
85    public Future<V> poll(long timeout, TimeUnit unit)
86            throws InterruptedException {
87        return completionQueue.poll(timeout, unit);
88    }
89
90}



通过观察实现类中的代码，我们可以发现这个方法非常简单，其原理分为以下几步：

1、在构造ExecutorCompletionService对象时，需要传入给定的线程池或者阻塞队列。

2、当我们提交任务到ExecutorCompletionService时，会将提交的任务包装成QueueingFuture对象，然后交由我们指定的线程池来执行。

3、当任务执行完成后，QueueingFuture对象会执行最终的done方法（QueueingFuture对象重新的方法），将RunnableFuture对象添加到指定的阻塞队列中。

4、我们可以通过poll或者take方法来获取队列中的RunnableFuture对象，以便获取执行结果。

由此可以发现我们获取到的任务执行结果，与提交到线程池的任务顺序是无关的，哪个任务先完成，就会被添加到队列中，我们就可以先获取执行结果。



3、使用场景



1、当我们不关注提交到线程池任务顺序以及任务执行完成获取结果的顺序时，我们就可以使用ExecutorCompletionService这个来执行任务。以下是示例代码。

1void solve(Executor e, Collection<Callable<Result>> solvers) throws InterruptedException, ExecutionException {
2        CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
3        for (Callable<Result> s : solvers) {
4            ecs.submit(s);
5        }
6        int n = solvers.size();
7        for (int i = 0; i < n; ++i) {
8            Result r = ecs.take().get();
9            if (r != null) {
10                use(r);
11            }
12        }
13    }

2、当多个任务同时执行，我们只需要获取第一个任务的执行结果，其余结果不需要关心时，也可以通过ExecutorCompletionService来执行任务。以下是示例代码。

1void solve(Executor e, Collection<Callable<Result>> solvers) throws InterruptedException {
2        CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
3        int n = solvers.size();
4        List<Future<Result>> futures = new ArrayList<Future<Result>>(n);
5        Result result = null;
6        try {
7            for (Callable<Result> s : solvers) {
8                futures.add(ecs.submit(s));
9            }
10
11            for (int i = 0; i < n; ++i) {
12                try {
13                    Result r = ecs.take().get();
14                    if (r != null) {
15                        result = r;
16                        break;
17                    }
18                } catch (ExecutionException ignore) {
19                }
20            }
21        } finally {
22            for (Future<Result> f : futures) {
23                f.cancel(true);
24            }
25        }
26
27        if (result != null) {
28            use(result);
29        }
30    }



4、代码实践



在业务上我们有这种场景，我们有一批订单进行批量更新，每处理完一单，我们都需要维护一下处理进度，保证订单处理进度实时更新成最新的进度数据，我们此时用到的就是ExecutorCompletionService。

1protected void parallelBatchUpdateWaybill(Map<String, LwbMain> lwbMainMap, Map<String, UpdateWaybillTaskDetail> taskDetailMap) {
2        long start = System.currentTimeMillis();
3        log.info("{} 并行批量更新订单开始：{}", traceId, taskNo);
4        int total = lwbMainMap.size();
5        BlockingQueue<Future<String>> blockingQueue = new LinkedBlockingQueue<>(total + 2);
6        ExecutorCompletionService<String> executorCompletionService = new ExecutorCompletionService<>(parallelUpdateWaybillExecutorService, blockingQueue);
7        for (Map.Entry<String, UpdateWaybillTaskDetail> entry : taskDetailMap.entrySet()) {
8            String lwbNo = entry.getKey();
9            LwbMain lwbMain = lwbMainMap.get(lwbNo);
10            UpdateWaybillTaskDetail taskDetail = entry.getValue();
11            executorCompletionService.submit(() -> this.updateSingleWaybill(lwbMain, taskDetail), "done");
12        }
13
14        for (int current = 0; current < taskDetailMap.size(); current++) {
15            try {
16                executorCompletionService.take().get();
17            } catch (Exception e) {
18                log.error("{} 获取并行批量更新订单结果异常：{}", traceId, e.getMessage(), e);
19            } finally {
20                jimClient.incr(importTaskNo);
21            }
22        }
23
24        long end = System.currentTimeMillis();
25        log.info("{} 并行批量更新订单结束：{}，耗时：{}", traceId, taskNo, (end - start));
26    }