Java并发之CompletionService详解

CompletionService是什么？

它是JUC包中的一个接口类，默认实现类只有一个ExecutorCompletionService。

CompletionService干什么的？

它将异步任务的生成和执行结果的处理进行了解耦，用来执行Callable的任务（实际也是通过Executor线程池执行的，只是它又加了一层封装），我们只需要调用它的take（阻塞）/poll（非阻塞）方法便可以获取到执行完的任务结果，最先获取到的必定是先执行完的异步任务结果。

主要应用场景：同时执行多个Callable任务，并且需对任务的返回结果进行处理。若想优先处理先执行完的任务结果，使用它尤其方便。

ExecutorCompletionService 源码解析

有三个成员变量，关键的是下面标注的变量1、变量2：

public class ExecutorCompletionService<V> implements CompletionService<V> {
    private final Executor executor; // 变量1： 线程池
    private final AbstractExecutorService aes;
    private final BlockingQueue<Future<V>> completionQueue; // 变量2： 阻塞队列

两个构造器，如下，用于初始化上面的三个成员变量，可以看到Executor线程池是必传的：

    public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        this.completionQueue = new LinkedBlockingQueue<Future<V>>();
    }

    public ExecutorCompletionService(Executor executor,
                                     BlockingQueue<Future<V>> completionQueue) {
        if (executor == null || completionQueue == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        this.completionQueue = completionQueue;
    }

核心方法submit，把task封装成一个QueueingFuture，作为执行任务交给线程池执行：

    public Future<V> submit(Callable<V> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<V> f = newTaskFor(task);
        executor.execute(new QueueingFuture(f));
        return f;
    }

下面再来看一下QueueingFuture对象，也是一个核心对象，如下所示。QueueingFuture是ExecutorCompletionService的私有内部类，它重写了FutureTask的done()方法。当任务执行完成set值的时候，会调用done方法，在done方法中将task存入阻塞队列。先执行完的任务就会先放入阻塞队列，所以我们从队列中取结果的时候，必定是先取到先执行完的任务。

    private class QueueingFuture extends FutureTask<Void> {
        QueueingFuture(RunnableFuture<V> task) {
            super(task, null);
            this.task = task;
        }
        protected void done() { completionQueue.add(task); }
        private final Future<V> task;
    }

总结一下，ExecutorCompletionService是通过QueueingFuture的done方法和阻塞队列实现的按照异步任务返回顺序来返回结果。

ExecutorCompletionService和ExecutorService的使用demo示例

Callable类：

class CsCallable implements Callable<String> {
    private String name;
    private long milli;

    public CsCallable(String name, long milli) {
        this.name = name;
        this.milli = milli;
    }

    @Override
    public String call() throws Exception {
        System.out.println("name:" + name);
        Thread.sleep(milli);
        return name + " after " + milli + "ms call back.";
    }
}

ExecutorCompletionService的demo：

public class CompletionServiceDemo {
    public static void main(String[] args) throws Exception {
        CompletionService completionService = new ExecutorCompletionService(Executors.newFixedThreadPool(4));
        completionService.submit(new CsCallable("xxx", 5000));
        completionService.submit(new CsCallable("www", 2000));
        completionService.submit(new CsCallable("zzz", 14000));
        completionService.submit(new CsCallable("yyy", 9000));
        for (int i = 0; i < 4; i++) {
            System.out.println(completionService.take().get());
        }
        System.out.println("----- main over -----");
    }
}

执行结果如下，可以看到早完成的任务结果能先获取到：

ExecutorService的demo：

public class ExecutorServiceDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        List<Future<String>> list = new ArrayList<>();
        list.add(executorService.submit(new CsCallable("xxx", 5000)));
        list.add(executorService.submit(new CsCallable("www", 2000)));
        list.add(executorService.submit(new CsCallable("zzz", 14000)));
        list.add(executorService.submit(new CsCallable("yyy", 9000)));
        for (Future<String> future : list) {
            System.out.println(future.get());
        }
        System.out.println("----- main over -----");
    }
}

执行结果如下，只能按照指定的顺序处理返回结果，无法先处理早完成的任务：