在多線程大師Doug Lea的貢獻下，在JDK1.5中加入了許多對并發(fā)特性的支持，例如：線程池。

一、簡介
線程池類為 java.util.concurrent.ThreadPoolExecutor，常用構(gòu)造方法為：
              
    ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                long keepAliveTime, TimeUnit unit,
                BlockingQueue workQueue,
                RejectedExecutionHandler handler)
               

    corePoolSize：   線程池維護線程的最少數(shù)量
    maximumPoolSize：線程池維護線程的最大數(shù)量
    keepAliveTime：  線程池維護線程所允許的空閑時間
    unit：           線程池維護線程所允許的空閑時間的單位
    workQueue：      線程池所使用的緩沖隊列
    handler：        線程池對拒絕任務(wù)的處理策略
   
    一個任務(wù)通過 execute(Runnable)方法被添加到線程池，任務(wù)就是一個 Runnable類型的對象，任務(wù)的執(zhí)行方法就是 Runnable類型對象的run()方法。
   
    當一個任務(wù)通過execute(Runnable)方法欲添加到線程池時：
   
    如果此時線程池中的數(shù)量小于corePoolSize，即使線程池中的線程都處于空閑狀態(tài)，也要創(chuàng)建新的線程來處理被添加的任務(wù)。

    如果此時線程池中的數(shù)量等于 corePoolSize，但是緩沖隊列 workQueue未滿，那么任務(wù)被放入緩沖隊列。

    如果此時線程池中的數(shù)量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數(shù)量小于maximumPoolSize，建新的線程來處理被添加的任務(wù)。

    如果此時線程池中的數(shù)量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數(shù)量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務(wù)。
   
    也就是：處理任務(wù)的優(yōu)先級為：
    核心線程corePoolSize、任務(wù)隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務(wù)。
   
    當線程池中的線程數(shù)量大于 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態(tài)的調(diào)整池中的線程數(shù)。
   
    unit可選的參數(shù)為java.util.concurrent.TimeUnit中的幾個靜態(tài)屬性：
    NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
   
    workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue
   
    handler有四個選擇：
    ThreadPoolExecutor.AbortPolicy()       
       拋出java.util.concurrent.RejectedExecutionException異常
    ThreadPoolExecutor.CallerRunsPolicy()  
       重試添加當前的任務(wù)，他會自動重復(fù)調(diào)用execute()方法
    ThreadPoolExecutor.DiscardOldestPolicy()
       拋棄舊的任務(wù)
    ThreadPoolExecutor.DiscardPolicy()     
       拋棄當前的任務(wù)

   
二、一般用法舉例
//------------------------------------------------------------
//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) {

        //構(gòu)造一個線程池   
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
                TimeUnit.SECONDS, new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        for(int i=1;i<=produceTaskMaxNumber;i++){
            try {              
                //產(chǎn)生一個任務(wù)，并將其加入到線程池
                String task = "task@ " + i;
    System.out.println("put " + task);
    threadPool.execute(new ThreadPoolTask(task));
    
    //便于觀察，等待一段時間
                Thread.sleep(produceTaskSleepTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 }

 /**
  * 線程池執(zhí)行的任務(wù)
  * @author hdpan
  */
    public static class ThreadPoolTask implements Runnable,Serializable{
     private static final long serialVersionUID = 0;
     //保存任務(wù)所需要的數(shù)據(jù)
        private Object threadPoolTaskData;
       
        ThreadPoolTask(Object tasks){
            this.threadPoolTaskData = tasks;
        }
        public void run(){
            //處理一個任務(wù)，這里的處理方式太簡單了，僅僅是一個打印語句
   System.out.println("start .."+threadPoolTaskData);
         try {
             ////便于觀察，等待一段時間
                Thread.sleep(consumeTaskSleepTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
            threadPoolTaskData = null;
        }
        public Object getTask(){
            return this.threadPoolTaskData;
        }
    }
}
//------------------------------------------------------------
說明：
1、在這段程序中，一個任務(wù)就是一個Runnable類型的對象，也就是一個ThreadPoolTask類型的對象。

2、一般來說任務(wù)除了處理方式外，還需要處理的數(shù)據(jù)，處理的數(shù)據(jù)通過構(gòu)造方法傳給任務(wù)。

3、在這段程序中，main()方法相當于一個殘忍的領(lǐng)導(dǎo)，他派發(fā)出許多任務(wù)，丟給一個叫 threadPool的任勞任怨的小組來做。

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

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

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

    因為隊員工作是需要成本的，如果工作很閑，閑到 3SECONDS都沒有新的任務(wù)了，那么有的隊員就會被解雇了，但是，為了小組的正常運轉(zhuǎn)，即使工作再閑，小組的隊員也不能少于兩個。

4、通過調(diào)整 produceTaskSleepTime和 consumeTaskSleepTime的大小來實現(xiàn)對派發(fā)任務(wù)和處理任務(wù)的速度的控制， 改變這兩個值就可以觀察不同速率下程序的工作情況。

5、通過調(diào)整4中所指的數(shù)據(jù)，再加上調(diào)整任務(wù)丟棄策略， 換上其他三種策略，就可以看出不同策略下的不同處理方式。

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