Java並發包中的幾種ExecutorService

1.CachedThreadPool

CachedThreadPool首先會按照需要創建足夠多的線程來執行任務(Task)。隨著程序執行的過程，有的線程執行完了任務，可以被重新循環使用時，才不再創建新的線程來執行任務。我們采用《Thinking In Java》中的例子來分析。

首先，任務定義如下(實現了Runnable接口，並且復寫了run方法)：

1. package net.jerryblog.concurrent; 
2. public class LiftOff implements Runnable{ 
3.     protected int countDown = 10; //Default 
4.     private static int taskCount = 0; 
5.     private final int id = taskCount++;  
6.     public LiftOff() {} 
7.     public LiftOff(int countDown) { 
8.         this.countDown = countDown; 
9.     } 
10.     public String status() { 
11.         return "#" + id + "(" + 
12.             (countDown > 0 ? countDown : "LiftOff!") + ") "; 
13.     } 
14.     @Override 
15.     public void run() { 
16.         while(countDown-- > 0) { 
17.             System.out.print(status()); 
18.             Thread.yield(); 
19.         } 
20.          
21.     }    
22. } 

采用CachedThreadPool方式執行編寫的客戶端程序如下：

1. package net.jerryblog.concurrent; 
2. import java.util.concurrent.ExecutorService; 
3. import java.util.concurrent.Executors; 
4. public class CachedThreadPool { 
5.     public static void main(String[] args) { 
6.         ExecutorService exec = Executors.newCachedThreadPool(); 
7.         for(int i = 0; i < 10; i++) { 
8.             exec.execute(new LiftOff()); 
9.         } 
10.         exec.shutdown();     
11.     } 
12. } 

上面的程序中，有10個任務，采用CachedThreadPool模式，exec沒遇到一個LiftOff的對象(Task)，就會創建一個線程來處理任務。現在假設遇到到第4個任務時，之前用於處理第一個任務的線程已經執行完成任務了，那麼不會創建新的線程來處理任務，而是使用之前處理第一個任務的線程來處理這第4個任務。接著如果遇到第5個任務時，前面那些任務都還沒有執行完，那麼就會又新創建線程來執行第5個任務。否則，使用之前執行完任務的線程來處理新的任務。