CompletionService和ExecutorCompletionService的好处和使用场景

《Java并发编程实践》一书6.3.5节CompletionService：Executor和BlockingQueue，有这样一段话：

  "如果向Executor提交了一组计算任务，并且希望在计算完成后获得结果，那么可以保留与每个任务关联的Future，然后反复使用get方法，同时将参数timeout指定为0，从而通过轮询来判断任务是否完成。这种方法虽然可行，但却有些繁琐。幸运的是，还有一种更好的方法：完成服务CompletionService。"

这是什么意思呢？我们通过一个例子，分别使用繁琐的做法和CompletionService来完成，清晰的对比能让我们更好的理解上面的一段话和CompletionService这个API提供的初衷。考虑这样的场景，有5个Callable任务分别返回5个整数，然后我们在main方法中按照各个任务完成的先后顺序，在控制台打印返回结果。

[java] view plain copy

1. package net.aty.completeservice;  
2.   
3. import java.util.concurrent.Callable;  
4. import java.util.concurrent.TimeUnit;  
5.   
6. public class ReturnAfterSleepCallable implements Callable<Integer>  
7. {  
8.     private int sleepSeconds;  
9.   
10.     private int returnValue;  
11.   
12.     public ReturnAfterSleepCallable(int sleepSeconds, int returnValue)  
13.     {  
14.         this.sleepSeconds = sleepSeconds;  
15.         this.returnValue = returnValue;  
16.     }  
17.   
18.     @Override  
19.     public Integer call() throws Exception  
20.     {  
21.         System.out.println("begin to execute.");  
22.   
23.         TimeUnit.SECONDS.sleep(sleepSeconds);  
24.   
25.         System.out.println("end to execute.");  
26.   
27.         return returnValue;  
28.     }  
29. }  

这个任务会接受2个参数，睡眠指定的时间后，返回指定的结果。睡眠时间越短，意味着任务越先执行完成。

1.繁琐的做法

通过一个List来保存每个任务返回的Future，然后轮询这些Future，直到每个Future都已完成。我们不希望出现因为排在前面的任务阻塞导致后面先完成的任务的结果没有及时获取的情况，所以在调用get方式时，需要将超时时间设置为0。

[java] view plain copy

1. package net.aty.completeservice;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. import java.util.concurrent.ExecutionException;  
6. import java.util.concurrent.ExecutorService;  
7. import java.util.concurrent.Executors;  
8. import java.util.concurrent.Future;  
9. import java.util.concurrent.TimeUnit;  
10. import java.util.concurrent.TimeoutException;  
11.   
12. public class TraditionalTest  
13. {  
14.     public static void main(String[] args)  
15.     {  
16.         int taskSize = 5;  
17.   
18.         ExecutorService executor = Executors.newFixedThreadPool(taskSize);  
19.   
20.         List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();  
21.   
22.         for (int i = 1; i <= taskSize; i++)  
23.         {  
24.             int sleep = taskSize - i; // 睡眠时间  
25.   
26.             int value = i; // 返回结果  
27.   
28.             // 向线程池提交任务  
29.             Future<Integer> future = executor.submit(new ReturnAfterSleepCallable(sleep, value));  
30.               
31.             // 保留每个任务的Future  
32.             futureList.add(future);  
33.         }  
34.           
35.         // 轮询,获取完成任务的返回结果  
36.         while(taskSize > 0)  
37.         {  
38.             for (Future<Integer> future : futureList)  
39.             {  
40.                 Integer result = null;  
41.                   
42.                 try  
43.                 {  
44.                     result = future.get(0, TimeUnit.SECONDS);  
45.                 } catch (InterruptedException e)  
46.                 {  
47.                     e.printStackTrace();  
48.                 } catch (ExecutionException e)  
49.                 {  
50.                     e.printStackTrace();  
51.                 } catch (TimeoutException e)  
52.                 {  
53.                     // 超时异常需要忽略,因为我们设置了等待时间为0,只要任务没有完成,就会报该异常  
54.                 }  
55.                   
56.                 // 任务已经完成  
57.                 if(result != null)  
58.                 {  
59.                     System.out.println("result=" + result);  
60.                       
61.                     // 从future列表中删除已经完成的任务  
62.                     futureList.remove(future);    
63.                     taskSize--;  
64.                     //此处必须break，否则会抛出并发修改异常。（也可以通过将futureList声明为CopyOnWriteArrayList类型解决）   
65.                     break; // 进行下一次while循环  
66.                 }  
67.             }  
68.         }  
69.           
70.         // 所有任务已经完成,关闭线程池  
71.         System.out.println("all over.");  
72.         executor.shutdown();  
73.     }  
74.       
75.       
76.       
77. }  

可见轮询future列表非常的复杂，而且还有很多异常需要处理，TimeOutException异常需要忽略；还要通过双重循环和break，防止遍历集合的过程中，出现并发修改异常。这么多需要考虑的细节，程序员很容易犯错。

2.使用CompletionService

[java] view plain copy

1. package net.aty.completeservice;  
2.   
3. import java.util.concurrent.CompletionService;  
4. import java.util.concurrent.ExecutionException;  
5. import java.util.concurrent.ExecutorCompletionService;  
6. import java.util.concurrent.ExecutorService;  
7. import java.util.concurrent.Executors;  
8.   
9. public class CompletionServiceTest  
10. {  
11.     public static void main(String[] args)  
12.     {  
13.         int taskSize = 5;  
14.   
15.         ExecutorService executor = Executors.newFixedThreadPool(taskSize);  
16.   
17.         // 构建完成服务  
18.         CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(  
19.                 executor);  
20.   
21.         for (int i = 1; i <= taskSize; i++)  
22.         {  
23.             int sleep = taskSize - i; // 睡眠时间  
24.   
25.             int value = i; // 返回结果  
26.   
27.             // 向线程池提交任务  
28.             completionService  
29.                     .submit(new ReturnAfterSleepCallable(sleep, value));  
30.         }  
31.   
32.         // 按照完成顺序,打印结果  
33.         for (int i = 0; i < taskSize; i++)  
34.         {  
35.             try  
36.             {  
37.                 System.out.println(completionService.take().get());  
38.             } catch (InterruptedException e)  
39.             {  
40.                 e.printStackTrace();  
41.             } catch (ExecutionException e)  
42.             {  
43.                 e.printStackTrace();  
44.             }  
45.         }  
46.   
47.         // 所有任务已经完成,关闭线程池  
48.         System.out.println("all over.");  
49.         executor.shutdown();  
50.     }  
51. }  

可见使用CompletionService不会有TimeOutExeception的问题，不用遍历future列表，不用担心并发修改异常。

3.CompletionService和ExecutorCompletionService的实现

   JDK源码中CompletionService的javadoc说明如下：

[java] view plain copy

1. /** 
2.  * A service that decouples the production of new asynchronous tasks 
3.  * from the consumption of the results of completed tasks.  Producers 
4.  * <tt>submit</tt> tasks for execution. Consumers <tt>take</tt> 
5.  * completed tasks and process their results in the order they 
6.  * complete.  
7.  */  

也就是说，CompletionService实现了生产者提交任务和消费者获取结果的解耦，生产者和消费者都不用关心任务的完成顺序，由CompletionService来保证，消费者一定是按照任务完成的先后顺序来获取执行结果。

ExecutorCompletionService是CompletionService的实现，融合了线程池Executor和阻塞队列BlockingQueue的功能。

[java] view plain copy

1. public ExecutorCompletionService(Executor executor) {  
2.        if (executor == null)  
3.            throw new NullPointerException();  
4.        this.executor = executor;  
5.        this.aes = (executor instanceof AbstractExecutorService) ?  
6.            (AbstractExecutorService) executor : null;  
7.        this.completionQueue = new LinkedBlockingQueue<Future<V>>();  
8.    }  

到这里可以推测，按照任务的完成顺序获取结果，就是通过阻塞队列实现的，阻塞队列刚好具有这样的性质：阻塞和有序。

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

[java] view plain copy

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

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

[java] view plain copy

1.  /** 
2.   * FutureTask extension to enqueue upon completion 
3.   */  
4. private class QueueingFuture extends FutureTask<Void> {  
5.         QueueingFuture(RunnableFuture<V> task) {  
6.             super(task, null);  
7.             this.task = task;  
8.         }  
9.         protected void done() { completionQueue.add(task); }  
10.         private final Future<V> task;  
11. }  

这里简单说明下：FutureTask.done()，这个方法默认什么都不做，就是一个回调，当提交的线程池中的任务完成时，会被自动调用。这也就说时候，当任务完成的时候，会自动执行QueueingFuture.done()方法，将返回结果加入到阻塞队列中，加入的顺序就是任务完成的先后顺序。