CompletionService

主要成员函数
public Future<V>  submit(Callable<V> task)
    从接口 CompletionService 复制的描述
    提交要执行的值返回任务，并返回表示挂起的任务结果的 Future。在完成时，可能会提取或轮询此任务。
    指定者：
        接口 CompletionService<V> 中的 submit
    参数：
        task - 要提交的任务 
    返回：
        一个表示挂起的任务完成的 Future
public Future<V>  submit(Runnable task,V result)
    从接口 CompletionService 复制的描述
    提交要执行的 Runnable 任务，并返回一个表示任务完成的 Future，可以提取或轮询此任务。
    指定者：
        接口 CompletionService<V> 中的 submit
    参数：
        task - 要提交的任务
        result - 要返回的已成功完成任务的结果 
    返回：
        一个表示挂起的任务完成的 Future，其 get() 方法将返回完成时给出的结果值
public Future<V>  take()
               throws InterruptedException
    从接口 CompletionService 复制的描述
    获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。
    指定者：
        接口 CompletionService<V> 中的 take
    返回：
        表示下一个已完成任务的 Future 
    抛出：
        InterruptedException - 如果在等待时被中断
public Future<V>  poll()
    从接口 CompletionService 复制的描述
    获取并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回 null。
    指定者：
        接口 CompletionService<V> 中的 poll
    返回：
        表示下一个已完成任务的 Future；如果不存在这样的任务，则返回 null
public Future<V>  poll(long timeout,
                      TimeUnit unit)
               throws InterruptedException
    从接口 CompletionService 复制的描述
    获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则将等待指定的时间（如果有必要）。
    指定者：
        接口 CompletionService<V> 中的 poll
    参数：
        timeout - 放弃之前需要等待的时间长度，以 unit 为时间单位
        unit - 确定如何解释 timeout 参数的 TimeUnit 
    返回：
        表示下一个已完成任务的 Future；如果等待了指定时间仍然不存在这样的任务，则返回 null 
    抛出：
        InterruptedException - 如果在等待时被中断

代码：

1. import java.util.Random;  
2. import java.util.concurrent.BlockingQueue;  
3. import java.util.concurrent.Callable;  
4. import java.util.concurrent.CompletionService;  
5. import java.util.concurrent.ExecutionException;  
6. import java.util.concurrent.ExecutorCompletionService;  
7. import java.util.concurrent.ExecutorService;  
8. import java.util.concurrent.Executors;  
9. import java.util.concurrent.Future;  
10. import java.util.concurrent.LinkedBlockingQueue;  
11.   
12. public class Test17 {  
13.     public static void main(String[] args) throws Exception {  
14.         Test17 t = new Test17();  
15.         t.count1();  
16.         t.count2();  
17.     }  
18. //使用阻塞容器保存每次Executor处理的结果，在后面进行统一处理  
19.     public void count1() throws Exception{  
20.         ExecutorService exec = Executors.newCachedThreadPool();  
21.         BlockingQueue<Future<Integer>> queue = new LinkedBlockingQueue<Future<Integer>>();  
22.         for(int i=0; i<10; i++){  
23.             Future<Integer> future =exec.submit(getTask());  
24.             queue.add(future);  
25.         }  
26.         int sum = 0;  
27.         int queueSize = queue.size();  
28.         for(int i=0; i<queueSize; i++){  
29.             sum += queue.take().get();  
30.         }  
31.         System.out.println("总数为："+sum);  
32.         exec.shutdown();  
33.     }  
34. //使用CompletionService(完成服务)保持Executor处理的结果  
35.     public void count2() throws InterruptedException, ExecutionException{  
36.         ExecutorService exec = Executors.newCachedThreadPool();  
37.         CompletionService<Integer> execcomp = new ExecutorCompletionService<Integer>(exec);  
38.         for(int i=0; i<10; i++){  
39.             execcomp.submit(getTask());  
40.         }  
41.         int sum = 0;  
42.         for(int i=0; i<10; i++){  
43. //检索并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。  
44.             Future<Integer> future = execcomp.take();  
45.             sum += future.get();  
46.         }  
47.         System.out.println("总数为："+sum);  
48.         exec.shutdown();  
49.     }  
50.     //得到一个任务  
51.     public Callable<Integer> getTask(){  
52.         final Random rand = new Random();  
53.         Callable<Integer> task = new Callable<Integer>(){  
54.             @Override  
55.             public Integer call() throws Exception {  
56.                 int i = rand.nextInt(10);  
57.                 int j = rand.nextInt(10);  
58.                 int sum = i*j;  
59.                 System.out.print(sum+"\t");  
60.                 return sum;  
61.             }  
62.         };  
63.         return task;  
64.     }