Java SE5的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代表一個有返回值得操作。

例項：平行計算求和

1. public class ConcurrentSum {  
2.     private int coreCpuNum;  
3.     private ExecutorService  executor;  
4.     private List<FutureTask<Long>> tasks = new ArrayList<FutureTask<Long>>();  
5.     public ConcurrentSum(){  
6.         coreCpuNum = Runtime.getRuntime().availableProcessors();  
7.         executor = Executors.newFixedThreadPool(coreCpuNum);  
8.     }  
9.     class SumCalculator implements Callable<Long>{  
10.         int nums[];  
11.         int start;  
12.         int end;  
13.         public SumCalculator(final int nums[],int start,int end){  
14.             this.nums = nums;  
15.             this.start = start;  
16.             this.end = end;  
17.         }  
18.         @Override  
19.         public Long call() throws Exception {  
20.             long sum =0;  
21.             for(int i=start;i<end;i++){  
22.                 sum += nums[i];  
23.             }  
24.             return sum;  
25.         }  
26.     }  
27.     public long sum(int[] nums){  
28.         int start,end,increment;  
29.         // 根據CPU核心個數拆分任務，建立FutureTask並提交到Executor   
30.         for(int i=0;i<coreCpuNum;i++){  
31.             increment = nums.length / coreCpuNum+1;  
32.             start = i*increment;  
33.             end = start+increment;  
34.             if(end > nums.length){  
35.                 end = nums.length;   
36.             }  
37.             SumCalculator calculator = new SumCalculator(nums, start, end);  
38.             FutureTask<Long> task = new FutureTask<Long>(calculator);  
39.             tasks.add(task);  
40.             if(!executor.isShutdown()){  
41.                 executor.submit(task);  
42.             }  
43.         }  
44.         return getPartSum();  
45.     }  
46.     public long getPartSum(){  
47.         long sum = 0;  
48.         for(int i=0;i<tasks.size();i++){  
49.             try {  
50.                 sum += tasks.get(i).get();  
51.             } catch (InterruptedException e) {  
52.                 e.printStackTrace();  
53.             } catch (ExecutionException e) {  
54.                 e.printStackTrace();  
55.             }  
56.         }  
57.         return sum;  
58.     }  
59.     public void close(){  
60.         executor.shutdown();  
61.     }  
62.     public static void main(String[] args) {  
63.         int arr[] = new int[]{1, 22, 33, 4, 52, 61, 7, 48, 10, 11 };  
64.         long sum = new ConcurrentSum().sum(arr);  
65.         System.out.println("sum: " + sum);  
66.     }  
67. }  

CompletionService

在上述例子中，getResult()方法的實現過程中，迭代了FutureTask的陣列，如果任務還沒有完成則當前執行緒會阻塞，如果我們希望任意任務完成後就把其結果加到result中，而不用依次等待每個任務完成，可以使用CompletionService。

它與ExecutorService最主要的區別在於submit的task不一定是按照加入時的順序完成的。CompletionService對ExecutorService進行了包裝，內部維護一個儲存Future物件的BlockingQueue。只有當這個Future物件狀態是結束的時候，才會加入到這個Queue中，take()方法其實就是Producer-Consumer中的Consumer。它會從Queue中取出Future物件，如果Queue是空的，就會阻塞在那裡，直到有完成的Future物件加入到Queue中。所以，先完成的必定先被取出。這樣就減少了不必要的等待時間。

例項：平行計算求和

1. public class ConcurrentSum2 {  
2.     private int coreCpuNum;  
3.     private ExecutorService  executor;  
4.     private CompletionService<Long> completionService;  
5.     public ConcurrentSum2(){  
6.         //.....  
7.     }  
8.     class SumCalculator implements Callable<Long>{  
9.         //.....  
10.     }  
11.     public long sum(int[] nums){  
12.         int start,end,increment;  
13.         // 根據CPU核心個數拆分任務，建立FutureTask並提交到Executor   
14.         for(int i=0;i<coreCpuNum;i++){  
15.             increment = nums.length / coreCpuNum+1;  
16.             start = i*increment;  
17.             end = start+increment;  
18.             if(end > nums.length){  
19.                 end = nums.length;   
20.             }  
21.             SumCalculator task = new SumCalculator(nums, start, end);  
22.             if(!executor.isShutdown()){  
23.                 completionService.submit(task);  
24.             }  
25.         }  
26.         return getPartSum();  
27.     }  
28.     public long getPartSum(){  
29.         long sum = 0;  
30.         for(int i=0;i<coreCpuNum;i++){  
31.             try {  
32.                 sum += completionService.take().get();  
33.             } catch (InterruptedException e) {  
34.                 e.printStackTrace();  
35.             } catch (ExecutionException e) {  
36.                 e.printStackTrace();  
37.             }  
38.         }  
39.         return sum;  
40.     }  
41.     public void close(){  
42.         executor.shutdown();  
43.     }  
44. }