java并发编程学习-ExecutorService和CompletionService的区别

程老师原文地址：http://flychao88.iteye.com/blog/1522755

我们现在在Java中使用多线程通常不会直接用Thread对象了，而是会用到java.util.concurrent包下的ExecutorService类来初始化一个线程池供我们使用。

之前我一直习惯自己维护一个list保存submit的callable task所返回的Future对象。

在主线程中遍历这个list并调用Future的get()方法取到Task的返回值。 

但是，我在很多地方会看到一些代码通过CompletionService包装ExecutorService，然后调用其take()方法去取Future对象。以前没研究过这两者之间的区别。

今天看了源代码之后就明白了。 

这两者最主要的区别在于submit的task不一定是按照加入自己维护的list顺序完成的。

从list中遍历的每个Future对象并不一定处于完成状态，这时调用get()方法就会被阻塞住，如果系统是设计成每个线程完成后就能根据其结果继续做后面的事，这样对于处于list后面的但是先完成的线程就会增加了额外的等待时间。 

而CompletionService的实现是维护一个保存Future对象的BlockingQueue。只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。它会从Queue中取出Future对象，如果Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。

所以，先完成的必定先被取出。这样就减少了不必要的等待时间。

*********************原文结束，以下为学习笔记*****************************

多线程经常会使用线程池（另开贴写线程池的深入分析），下面学习笔记从demo跟源码分析两部分。

照着文章写个demo测试以下。自己跑了一下，觉得时间差不多（数据需要少的原因），但是代码简洁了不少。

package com.hshbic.uplus.collect.util;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.CompletionService;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorCompletionService;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

public class Test1 {

public static void main(String[] args) throws Exception {

Test1 t = new Test1();

long t1 = System.currentTimeMillis();

t.count1();

System.out.println("use"+(System.currentTimeMillis()-t1));

long t2 =  System.currentTimeMillis();

t.count2();

System.out.println("use"+(System.currentTimeMillis()-t2));

}

//使用list保存每次Executor处理的结果，在后面进行统一处理

public void count1() throws Exception{

ExecutorService exec = Executors.newCachedThreadPool();

List> futureList = new ArrayList>();

int numThread = 10;

for(int i=0; i

Future future =exec.submit(new Test1.Task(i));

futureList.add(future);

}

int queueSize = futureList.size();

while(numThread > 0){

for(Future future : futureList){

String result = null;

try {

result = future.get(0, TimeUnit.SECONDS);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

//超时异常直接忽略

}

if(null != result){

futureList.remove(future);

numThread--;

System.out.println(result);

//此处必须break，否则会抛出并发修改异常。（也可以通过将futureList声明为CopyOnWriteArrayList类型解决）

break;

}

}

}

exec.shutdown();

}

//使用CompletionService(完成服务)保持Executor处理的结果

public void count2() throws InterruptedException, ExecutionException{

ExecutorService exec = Executors.newCachedThreadPool();

CompletionService execcomp = new ExecutorCompletionService(exec);

for(int i=0; i<10; i++){

execcomp.submit(new Test1.Task(i));

}

for(int i=0; i<10; i++){

//检索并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。

Future future = execcomp.take();

System.out.println( future.get());

}

exec.shutdown();

}

//task

static class Task implements Callable{

private int i;

public Task(int i){

this.i = i;

}

@Override

public String call() throws Exception {

Thread.sleep(10000);

return Thread.currentThread().getName() + "执行完任务：" + i;

}

}

}

运行结果：

pool-1-thread-1执行完任务：0

pool-1-thread-2执行完任务：1

pool-1-thread-3执行完任务：2

pool-1-thread-4执行完任务：3

pool-1-thread-5执行完任务：4

pool-1-thread-8执行完任务：7

pool-1-thread-6执行完任务：5

pool-1-thread-7执行完任务：6

pool-1-thread-10执行完任务：9

pool-1-thread-9执行完任务：8

use10011

pool-2-thread-1执行完任务：0

pool-2-thread-4执行完任务：3

pool-2-thread-5执行完任务：4

pool-2-thread-8执行完任务：7

pool-2-thread-9执行完任务：8

pool-2-thread-6执行完任务：5

pool-2-thread-2执行完任务：1

pool-2-thread-7执行完任务：6

pool-2-thread-3执行完任务：2

pool-2-thread-10执行完任务：9

use10010

ExecutorCompletionService是Executor和BlockingQueue的结合体。源码如下：

 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>();

    }

 任务的提交和执行都是委托给Executor来完成。当提交某个任务时，该任务首先将被包装为一个QueueingFuture，

 public Future submit(Callable task) {

        if (task == null) throw new NullPointerException();

        RunnableFuture f = newTaskFor(task);

        executor.execute(new QueueingFuture(f));

        return f;

    }

QueueingFuture是FutureTask的一个子类，通过改写该子类的done方法，可以实现当任务完成时，将结果放入到BlockingQueue中。

 private class QueueingFuture extends FutureTask {

        QueueingFuture(RunnableFuture task) {

            super(task, null);

            this.task = task;

        }

        protected void done() { completionQueue.add(task); }

        private final Future task;

    }

 而通过使用BlockingQueue的take或poll方法，则可以得到结果。在BlockingQueue不存在元素时，这两个操作会阻塞，一旦有结果加入，则立即返回。

public Future take() throws InterruptedException {

        return completionQueue.take();

    }

    public Future poll() {

        return completionQueue.poll();

    }

****************************************************