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 -----");
    }
}

執行結果如下，只能按照指定的順序處理返回結果，無法先處理早完成的任務：