CompletionService 和ExecutorService的区别和用法

JavaSE5的Java.util.concurrent包中的执行器（Executor）将为你管理Thread对象，从而简化了并发编程。Executor在客户端和执行任务之间提供了一个间接层，Executor代替客户端执行任务。Executor允许你管理异步任务的执行，而无须显式地管理线程的生命周期。Executor在Java SE5/6中时启动任务的优选方法。Executor引入了一些功能类来管理和使用线程Thread，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等

创建线程池

Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

public static ExecutorService newFixedThreadPool(int nThreads)

创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()

创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor()

创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

见类图，接口Executor只有一个方法execute，接口ExecutorService扩展了Executor并添加了一些生命周期管理的方法，如shutdown、submit等。一个Executor的生命周期有三种状态，运行 ，关闭 ，终止。

Callable，Future用于返回结果

Future<V>代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞。FutureTask<V>实现了Future<V>和Runable<V>。Callable代表一个有返回值得操作。

实例：用ExecutorService  实现对一个大数组并行求和

1. package executor;
2. import java.util.*;
3. import java.util.concurrent.*;
4. /*
5. * 并行计算求和.
6. * 本例中，把一个整数数组的求和分解到每个线程中，每个线程求该数值的部分和，
7. * 然后主程序把各个和再次求和就能得到最后的数字。从这个架构上跟mapreduce有点神似。
8. *
9. */
10. public class ExecutorServiceParalelSumdemo {
11. private int coreCpuNum;
12. private ExecutorService  executor;
13. /*
14. * save the result of each thread's sum calculation
15. *
16. */
17. private List<FutureTask<Long>> tasks = new ArrayList<FutureTask<Long>>();
18. public ExecutorServiceParalelSumdemo(){
19. coreCpuNum = Runtime.getRuntime().availableProcessors();
20. System.out.println("this host has "+coreCpuNum+ " CPU(s)");
21. //for before Java 8.0
22. //executor = Executors.newFixedThreadPool(coreCpuNum);
23. //this CPU parallelism API is Java8 or later ONLY
24. executor = Executors.newWorkStealingPool(coreCpuNum);
25. }
26. /*
27. * thread main body
28. */
29. class CalculatorTask implements Callable<Long>{
30. int nums[];
31. int start;
32. int end;
33. public CalculatorTask(final int nums[],int start,int end){
34. this.nums = nums;
35. this.start = start;
36. this.end = end;
37. }
38. @Override
39. public Long call() throws Exception {
40. long sum =0;
41. for(int i=start;i<end;i++){
42. sum += nums[i];
43. }
44. return sum;
45. }
46. }
47. private long getFinalSum(){
48. long sum = 0;
49. System.out.println(tasks.size() + " future tasks in pool");
50. for(int i=0;i<tasks.size();i++){
51. try {
52. /*
53. * If this future's thread not return its result,
54. * get() will block here. So perf issue introduced.
55. * we can use CompletionService to solve this potential issue.
56. */
57. sum += tasks.get(i).get();
58. } catch (InterruptedException e) {
59. e.printStackTrace();
60. } catch (ExecutionException e) {
61. e.printStackTrace();
62. }
63. }
64. return sum;
65. }
66. public long ParallelSum(int[] nums){
67. int start,end,increment;
68. // 根据CPU核心个数拆分任务，创建每个thread和对应的 FutureTask，并提交到ExecutorService中。
69. for(int i=0;i<coreCpuNum;i++) {
70. increment = (nums.length/coreCpuNum)+1;
71. start = i*increment;
72. end = start+increment;
73. if(end > nums.length){
74. end = nums.length;
75. }
76. //create thread tasks
77. CalculatorTask calculator = new CalculatorTask(nums, start, end);
78. //create each future result per thread task
79. FutureTask<Long> task = new FutureTask<Long>(calculator);
80. tasks.add(task);
81. if(!executor.isShutdown()){
82. //execute() can't return result
83. executor.submit(task);
84. }
85. }
86. return getFinalSum();
87. }
88. public void close(){
89. executor.shutdown();
90. }
91. }

在上述例子中，getResult()方法的实现过程中，迭代了FutureTask的数组，如果任务还没有完成则当前线程会阻塞，如果我们希望任意任务完成后就把其结果加到result中，而不用依次等待每个任务完成，可以使用CompletionService。

它与ExecutorService最主要的区别在于submit的task不一定是按照加入时的顺序完成的。CompletionService对ExecutorService进行了包装，内部维护一个保存Future对象的BlockingQueue。只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。它会从Queue中取出Future对象，如果Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。所以，先完成的必定先被取出。这样就减少了不必要的等待时间。

CompletionService版本的求和例子

1. package executor;
2. import java.util.*;
3. import java.util.concurrent.*;
4. public class CompletionServiceDemo {
5. /*
6. * 并行计算求和.
7. * 本例中，把一个整数数组的求和分解到每个线程中，每个线程求该数值的部分和，
8. * 然后主程序把各个和再次求和就能得到最后的数字。从这个架构上跟mapreduce有点神似。
9. *
10. */
11. private int coreCpuNum;
12. private ExecutorService  executor;
13. /*
14. * CompletionService与ExecutorService最主要的区别在于
15. *前者submit的task不一定是按照加入时的顺序完成的。CompletionService对ExecutorService进行了包装，
16. *内部维护一个保存Future对象的BlockingQueue。
17. *只有当这个Future对象状态是结束的时候，才会加入到这个Queue中，take()方法其实就是Producer-Consumer中的Consumer。
18. *它会从Queue中取出Future对象，如果Queue是空的，就会阻塞在那里，直到有完成的Future对象加入到Queue中。
19. *所以，先完成的必定先被取出。这样就减少了不必要的等待时间。
20. *
21. */
22. /*
23. * CompletionService has a internal bloking queue to save the result of each
24. * thread's sum calculation. so List<FutureTask<Long>> tasks appears unnecessary now
25. *
26. */
27. private CompletionService<Long> mcs;
28. /*
29. * save the result of each thread's sum calculation
30. *
31. */
32. public CompletionServiceDemo(){
33. coreCpuNum = Runtime.getRuntime().availableProcessors();
34. System.out.println("this host has "+coreCpuNum+ " CPU(s)");
35. //for before Java 8.0
36. //executor = Executors.newFixedThreadPool(coreCpuNum);
37. //this CPU parallelism API is Java8 or later ONLY
38. executor = Executors.newWorkStealingPool(coreCpuNum);
39. mcs=new ExecutorCompletionService<>(executor);
40. }
41. /*
42. * thread main body
43. */
44. class CalculatorTask implements Callable<Long>{
45. int nums[];
46. int start;
47. int end;
48. public CalculatorTask(final int nums[],int start,int end){
49. this.nums = nums;
50. this.start = start;
51. this.end = end;
52. }
53. @Override
54. public Long call() throws Exception {
55. long sum =0;
56. for(int i=start;i<end;i++){
57. sum += nums[i];
58. }
59. return sum;
60. }
61. }
62. private long getFinalSum(){
63. long sum = 0;
64. for(int i=0;i<coreCpuNum;i++){
65. try {
66. /*
67. * get one complete result from CompletionServer internal
68. * blocking queue
69. */
70. sum += mcs.take().get();
71. } catch (InterruptedException e) {
72. e.printStackTrace();
73. } catch (ExecutionException e) {
74. e.printStackTrace();
75. }
76. }
77. return sum;
78. }
79. public long ParallelSum(int[] nums){
80. int start,end,increment;
81. // 根据CPU核心个数拆分任务，创建每个thread和对应的 FutureTask，并提交到ExecutorService中。
82. for(int i=0;i<coreCpuNum;i++) {
83. increment = (nums.length/coreCpuNum)+1;
84. start = i*increment;
85. end = start+increment;
86. if(end > nums.length){
87. end = nums.length;
88. }
89. //create thread tasks
90. CalculatorTask mthread = new CalculatorTask(nums, start, end);
91. if(!executor.isShutdown()){
92. mcs.submit(mthread);
93. }
94. }
95. return getFinalSum();
96. }
97. public void close(){
98. executor.shutdown();
99. }
100. }

ExcutorServer thread pool demo show
this host has 4 CPU(s)
4 future tasks in pool
result per ExecutorServiceParalelSumdemo = 452613
CompletionServiceDemo thread pool demo show
this host has 4 CPU(s)
result per CompletionServiceDemo = 452613