一、簡介
線程池類爲 java.util.concurrent.ThreadPoolExecutor，常用構造方法爲：
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue 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()
拋棄當前的任務
二、一般用法舉例
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(3),new ThreadPoolExecutor.CallerRunsPolicy());
for(int i=1;i<=produceTaskMaxNumber;i++){
try {
//產生一個任務，並將其加入到線程池
String task = "task@ " + 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;
}
}
}
運行結果：
C:\java>java TestThreadPool
put task@ 1
start ...task@ 1
put task@ 2
start ...task@ 2
put task@ 3
put task@ 4
put task@ 5
put task@ 6
start ...task@ 3
put task@ 7
start ...task@ 4
put task@ 8
start ...task@ 8
start ...task@ 5
start ...task@ 6
start ...task@ 7
put task@ 9
start ...task@ 9
put task@ 10
start ...task@ 10
// — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — 說明：
1、在這段程序中，一個任務就是一個Runnable類型的對象，也就是一個ThreadPoolTask類型的對象。
2、一般來說任務除了處理方式外，還需要處理的數據，處理的數據通過構造方法傳給任務。
3、在這段程序中，main()方法相當於一個殘忍的領導，他派發出許多任務，丟給一個叫 threadPool的任勞任怨的小組來做。
這個小組裏面隊員至少有兩個，如果他們兩個忙不過來， 任務就被放到任務列表裏面。
如果積壓的任務過多，多到任務列表都裝不下(超過3個)的時候，就僱傭新的隊員來幫忙。但是基於成本的考慮，不能僱傭太多的隊員， 至多隻能僱傭 4個。
如果四個隊員都在忙時，再有新的任務， 這個小組就處理不了了，任務就會被通過一種策略來處理，我們的處理方式是不停的派發， 直到接受這個任務爲止(更殘忍！呵呵)。
因爲隊員工作是需要成本的，如果工作很閒，閒到 3SECONDS都沒有新的任務了，那麼有的隊員就會被解僱了，但是，爲了小組的正常運轉，即使工作再閒，小組的隊員也不能少於兩個。
4、通過調整 produceTaskSleepTime和 consumeTaskSleepTime的大小來實現對派發任務和處理任務的速度的控制， 改變這兩個值就可以觀察不同速率下程序的工作情況。
5、通過調整4中所指的數據，再加上調整任務丟棄策略， 換上其他三種策略，就可以看出不同策略下的不同處理方式。
6、對於其他的使用方法，參看jdk的幫助，很容易理解和使用。