CompletionService接口的API文档说明如下：

将生产新的异步任务与使用已完成任务的结果分离开来的服务。生产者submit 执行的任务。使用者 take已完成的任务，并按照完成这些任务的顺序处理它们的结果。例如，CompletionService可以用来管理异步 IO ，执行读操作的任务作为程序或系统的一部分提交，然后，当完成读操作时，会在程序的不同部分执行其他操作，执行操作的顺序可能与所请求的顺序不同。

通常，CompletionService依赖于一个单独的Executor来实际执行任务，在这种情况下，CompletionService只管理一个内部完成队列。ExecutorCompletionService类提供了此方法的一个实现。

内存一致性效果：线程中向CompletionService提交任务之前的操作happen-before 该任务执行的操作，后者依次happen-before 紧跟在从对应take()成功返回的操作。

CompletionService接口定义的方法如下：

Future<V> submit(Callable<V> task);
Future<V> submit(Runnable task, V result);
Future<V> take() throws InterruptedException;
Future<V> poll();
Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;

为什么引入这个接口

这里需要和ExecutorService进行对比，来说明为什么要引入这个接口。摘取ExecutorService相关的方法，如下所示：

<T> Future<T> submit(Callable<T> task);    
Future<?> submit(Runnable task);
<T> Future<T> submit(Runnable task, T result);

从上面可以看到CompletionService有与ExecutorService相似的submit方法，作用都是提交一个可运行或可调用的任务，然后返回一个Future对象。与ExecutorService不同的是，CompletionService还提供了名称为take和poll的方法。这两个名称的方法，应该是比较熟悉了吧，就是操作队列元素的方法——从队列取元素。还可以看到取出的元素依然是Future类型的。

那么取出的这个Future类型的对象到底是什么呢？

Future对象是任务执行后用于异步获取执行结果的对象，使用ExecutorService对象执行任务，要获取结果，我们通常是这样做的：

Future future = executorService.submit(task);
....
future.get();

我们知道Future的get方法是阻塞的，只有task执行完成后，这个方法才会有真实的返回。也就是说代码中调用get方法可以说是尝试式的获取一下，获取不到阻塞也没关系。不过，现在有这样的需求，我就需要明明切切的获取结果，得到这个Future对象后调用get不会阻塞。想要获得这样的Future对象，那么就说明任务的执行是需要完成的，这样调用future的get方法的时候就不会阻塞。

任务的执行在执行器的内部，那么可以这样思考，任务在真正执行完之后将Future对象保持到一个容器里，然后调用端代码从这个容器里取出Future进而执行get方法。

CompletionService就是为这样的需求定义的接口。CompletionService的实现内部会持有一个队列，队列存放任务执行完成后的Future对象，通过take和poll方法获取，take和poll方法取出的就是任务在完成状态时的Future对象。

执行原理

这里通过CompletionService的实现类ExecutorCompletionService来说明实现原理。

1. 保存任务完成状态下的Future对象的容器

ExecutorCompletionService内部定义了completionQueue代表此容器：

private final BlockingQueue<Future<V>> completionQueue;

构造ExecutorCompletionService对象，不明确指定的话，completionQueue的初始化如下：

this.completionQueue = new LinkedBlockingQueue<Future<V>>();

当然可以通过构造方法明确地指定。

2. 任务完成状态下的Future对象存入

也就是completionQueue对象元素的填充。

先来看任务的提交：

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

将提交的任务包装成RunnableFuture，使其可以异步获取结果。同时上面做了二次包装：

new QueueingFuture(f)

QueueingFuture的定义如下：

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

这里看到通过done方法会将RunnableFuture对象存入到completionQueue中。那么done方法什么时候执行呢？这个就涉及到FutureTask的知识，不过也可以简单的一句话说明：当任务执行完成的时候调用done方法。下面是FutureTask类中调用done方法的片段：

private void finishCompletion() {
    // .....
    done();
    callable = null;        // to reduce footprint
}

注意：关于这个类还有一点需要注意，就是这个类并不负责任务的调度，任务的调度委派给Executor对象（从构造方法就可以看出这一点），只负责任务完成后Future对象的存入。