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代表一個異步執行的操作，通過get()方法可以獲得操作的結果，如果異步操作還沒有完成，則，get()會使當前線程阻塞。FutureTask實現了Future和Runable。Callable代表一個有返回值得操作。

實例：并行計算求和：

public class ConcurrentSum { private int coreCpuNum; private ExecutorService executor; private List<FutureTask<Long>> tasks = new ArrayList<FutureTask<Long>>(); public ConcurrentSum(){ coreCpuNum = Runtime.getRuntime().availableProcessors(); executor = Executors.newFixedThreadPool(coreCpuNum); } class SumCalculator implements Callable<Long>{ int nums[]; int start; int end; public SumCalculator(final int nums[],int start,int end){ this.nums = nums; this.start = start; this.end = end; } @Override public Long call() throws Exception { long sum =0; for(int i=start;i<end;i++){ sum += nums[i]; } return sum; } } public long sum(int[] nums){ int start,end,increment; // 根據CPU核心個數拆分任務，創建FutureTask并提交到Executor for(int i=0;i<coreCpuNum;i++){ increment = nums.length / coreCpuNum+1; start = i*increment; end = start+increment; if(end > nums.length){ end = nums.length; } SumCalculator calculator = new SumCalculator(nums, start, end); FutureTask<Long> task = new FutureTask<Long>(calculator); tasks.add(task); if(!executor.isShutdown()){ executor.submit(task); } } return getPartSum(); } public long getPartSum(){ long sum = 0; for(int i=0;i<tasks.size();i++){ try { sum += tasks.get(i).get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } return sum; } public void close(){ executor.shutdown(); } public static void main(String[] args) { int arr[] = new int[]{1, 22, 33, 4, 52, 61, 7, 48, 10, 11 }; long sum = new ConcurrentSum().sum(arr); System.out.println("sum: " + sum); } }

CompletionService

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

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

實例：并行計算求和

public class ConcurrentSum2 { private int coreCpuNum; private ExecutorService executor; private CompletionService<Long> completionService; public ConcurrentSum2(){ //..... } class SumCalculator implements Callable<Long>{ //..... } public long sum(int[] nums){ int start,end,increment; // 根據CPU核心個數拆分任務，創建FutureTask并提交到Executor for(int i=0;i<coreCpuNum;i++){ increment = nums.length / coreCpuNum+1; start = i*increment; end = start+increment; if(end > nums.length){ end = nums.length; } SumCalculator task = new SumCalculator(nums, start, end); if(!executor.isShutdown()){ completionService.submit(task); } } return getPartSum(); } public long getPartSum(){ long sum = 0; for(int i=0;i<coreCpuNum;i++){ try { sum += completionService.take().get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } return sum; } public void close(){ executor.shutdown(); } }

總結

以上是生活随笔為你收集整理的【Java并发编程】java并发框架Executor学习笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。