[轉載]Java併發包中的幾種ExecutorService

 1.CachedThreadPool

    CachedThreadPool首先會按照須要建立足夠多的線程來執行任務(Task)。隨着程序執行的過程，有的線程執行完了任務，能夠被從新循環使用時，纔再也不建立新的線程來執行任務。咱們採用《Thinking In Java》中的例子來分析。

    首先，任務定義以下(實現了Runnable接口，而且複寫了run方法)：

package net.jerryblog.concurrent; 
public class LiftOff implements Runnable{ 
    protected int countDown = 10; //Default 
    private static int taskCount = 0; 
    private final int id = taskCount++;  
    public LiftOff() {} 
    public LiftOff(int countDown) { 
        this.countDown = countDown; 
    } 
    public String status() { 
        return "#" + id + "(" + 
            (countDown > 0 ? countDown : "LiftOff!") + ") "; 
    } 
    @Override 
    public void run() { 
        while(countDown-- > 0) { 
            System.out.print(status()); 
            Thread.yield(); 
        } 
         
    }    
}

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

package net.jerryblog.concurrent; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
public class CachedThreadPool { 
    public static void main(String[] args) { 
        ExecutorService exec = Executors.newCachedThreadPool(); 
        for(int i = 0; i < 10; i++) { 
            exec.execute(new LiftOff()); 
        } 
        exec.shutdown();     
    } 
}

 上面的程序中，有10個任務，採用CachedThreadPool模式，exec沒遇到一個LiftOff的對象(Task)，就會建立一個線程來處理任務。如今假設遇到到第4個任務時，以前用於處理第一個任務的線程已經執行完成任務了，那麼不會建立新的線程來處理任務，而是使用以前處理第一個任務的線程來處理這第4個任務。接着若是遇到第5個任務時，前面那些任務都尚未執行完，那麼就會又新建立線程來執行第5個任務。不然，使用以前執行完任務的線程來處理新的任務。

2.FixedThreadPool

     FixedThreadPool模式會使用一個優先固定數目的線程來處理若干數目的任務。規定數目的線程處理全部任務，一旦有線程處理完了任務就會被用來處理新的任務(若是有的話)。這種模式與上面的CachedThreadPool是不一樣的，CachedThreadPool模式下處理必定數量的任務的線程數目是不肯定的。而FixedThreadPool模式下最多 的線程數目是必定的。

    採用FixedThreadPool模式編寫客戶端程序以下：

package net.jerryblog.concurrent; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
public class FixedThreadPool { 
    public static void main(String[] args) {
        //三個線程來執行五個任務 
        ExecutorService exec = Executors.newFixedThreadPool(3);    
        for(int i = 0; i < 5; i++) { 
            exec.execute(new LiftOff()); 
        } 
        exec.shutdown(); 
    } 
}

3.SingleThreadExecutor模式

    SingleThreadExecutor模式只會建立一個線程。它和FixedThreadPool比較相似，不過線程數是一個。若是多個任務被提交給SingleThreadExecutor的話，那麼這些任務會被保存在一個隊列中，而且會按照任務提交的順序，一個先執行完成再執行另一個線程。

    SingleThreadExecutor模式能夠保證只有一個任務會被執行。這種特色能夠被用來處理共享資源的問題而不須要考慮同步的問題。

    SingleThreadExecutor模式編寫的客戶端程序以下： 

package net.jerryblog.concurrent; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
public class SingleThreadExecutor { 
    public static void main(String[] args) { 
        ExecutorService exec = Executors.newSingleThreadExecutor(); 
        for (int i = 0; i < 2; i++) { 
            exec.execute(new LiftOff()); 
        } 
    } 
}

    這種模式下執行的結果以下：

#0(9) #0(8) #0(7) #0(6) #0(5) #0(4) #0(3) #0(2) #0(1) #0(LiftOff!)
#1(9) #1(8) #1(7) #1(6) #1(5) #1(4) #1(3) #1(2) #1(1) #1(LiftOff!)

    第一個任務執行完了以後纔開始執行第二個任務。  

轉自：http://wawlian.iteye.com/blog/1315256