在多執行緒大師Doug Lea的貢獻下，在JDK1.5中加入了許多對併發特性的支援，例如：執行緒池。

一、簡介
執行緒池類為 java.util.concurrent.ThreadPoolExecutor，常用構造方法為：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)

corePoolSize： 執行緒池維護執行緒的最少數量
maximumPoolSize：執行緒池維護執行緒的最大數量
keepAliveTime： 執行緒池維護執行緒所允許的空閒時間
unit： 執行緒池維護執行緒所允許的空閒時間的單位
workQueue： 執行緒池所使用的緩衝佇列
handler： 執行緒池對拒絕任務的處理策略

一個任務通過 execute(Runnable)方法被新增到執行緒池，任務就是一個 Runnable型別的物件，任務的執行方法就是 Runnable型別物件的run()方法。

當一個任務通過execute(Runnable)方法欲新增到執行緒池時：

如果此時執行緒池中的數量小於corePoolSize，即使執行緒池中的執行緒都處於空閒狀態，也要建立新的執行緒來處理被新增的任務。

如果此時執行緒池中的數量等於 corePoolSize，但是緩衝佇列 workQueue未滿，那麼任務被放入緩衝佇列。

如果此時執行緒池中的數量大於corePoolSize，緩衝佇列workQueue滿，並且執行緒池中的數量小於maximumPoolSize，建新的執行緒來處理被新增的任務。

如果此時執行緒池中的數量大於corePoolSize，緩衝佇列workQueue滿，並且執行緒池中的數量等於maximumPoolSize，那麼通過 handler所指定的策略來處理此任務。

也就是：處理任務的優先順序為：
核心執行緒corePoolSize、任務佇列workQueue、最大執行緒maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。

當執行緒池中的執行緒數量大於 corePoolSize時，如果某執行緒空閒時間超過keepAliveTime，執行緒將被終止。這樣，執行緒池可以動態的調整池中的執行緒數。

unit可選的引數為java.util.concurrent.TimeUnit中的幾個靜態屬性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue

handler有四個選擇：
ThreadPoolExecutor.AbortPolicy()
丟擲java.util.concurrent.RejectedExecutionException異常
ThreadPoolExecutor.CallerRunsPolicy()
重試添加當前的任務，他會自動重複呼叫execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
拋棄舊的任務
ThreadPoolExecutor.DiscardPolicy()
拋棄當前的任務

二、一般用法舉例
//------------------------------------------------------------
//TestThreadPool.java
//package cn.simplelife.exercise;

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {

private static int produceTaskSleepTime = 2;
private static int consumeTaskSleepTime = 2000;
private static int produceTaskMaxNumber = 10;

public static void main(String[] args) {

//構造一個執行緒池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
new ThreadPoolExecutor.DiscardOldestPolicy());

for(int i=1;i<=produceTaskMaxNumber;i++){
try {
//產生一個任務，並將其加入到執行緒池
String task = "[email protected] " + i;
System.out.println("put " + task);
threadPool.execute(new ThreadPoolTask(task));

//便於觀察，等待一段時間
Thread.sleep(produceTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
}
}

/**
* 執行緒池執行的任務
* @author hdpan
*/
public static class ThreadPoolTask implements Runnable,Serializable{
private static final long serialVersionUID = 0;
//儲存任務所需要的資料
private Object threadPoolTaskData;

ThreadPoolTask(Object tasks){
this.threadPoolTaskData = tasks;
}
public void run(){
//處理一個任務，這裡的處理方式太簡單了，僅僅是一個列印語句
System.out.println("start .."+threadPoolTaskData);
try {
////便於觀察，等待一段時間
Thread.sleep(consumeTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
threadPoolTaskData = null;
}
public Object getTask(){
return this.threadPoolTaskData;
}
}
}
//------------------------------------------------------------
說明：
1、在這段程式中，一個任務就是一個Runnable型別的物件，也就是一個ThreadPoolTask型別的物件。

2、一般來說任務除了處理方式外，還需要處理的資料，處理的資料通過構造方法傳給任務。

3、在這段程式中，main()方法相當於一個殘忍的領導，他派發出許多工，丟給一個叫 threadPool的任勞任怨的小組來做。

這個小組裡面隊員至少有兩個，如果他們兩個忙不過來，任務就被放到任務列表裡面。

如果積壓的任務過多，多到任務列表都裝不下(超過3個)的時候，就僱傭新的隊員來幫忙。但是基於成本的考慮，不能僱傭太多的隊員，至多隻能僱傭 4個。

如果四個隊員都在忙時，再有新的任務，這個小組就處理不了了，任務就會被通過一種策略來處理，我們的處理方式是不停的派發，直到接受這個任務為止(更殘忍！呵呵)。

因為隊員工作是需要成本的，如果工作很閒，閒到 3SECONDS都沒有新的任務了，那麼有的隊員就會被解僱了，但是，為了小組的正常運轉，即使工作再閒，小組的隊員也不能少於兩個。

4、通過調整 produceTaskSleepTime和 consumeTaskSleepTime的大小來實現對派發任務和處理任務的速度的控制，改變這兩個值就可以觀察不同速率下程式的工作情況。

5、通過調整4中所指的資料，再加上調整任務丟棄策略，換上其他三種策略，就可以看出不同策略下的不同處理方式。

6、對於其他的使用方法，參看jdk的幫助，很容易理解和使用。