執行緒池的作用:
 
執行緒池作用就是限制系統中執行執行緒的數量。
 
根據系統的環境情況，可以自動或手動設定執行緒數量，達到執行的最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用執行緒池控制執行緒數量，其他執行緒排隊等候。一個任務執行完畢，再從佇列的中取最前面的任務開始執行。若佇列中沒有等待程序，執行緒池的這一資源處於等待。當一個新任務需要執行時，如果執行緒池中有等待的工作執行緒，就可以開始運行了；否則進入等待佇列。

為什麼要用執行緒池:
 

1. 減少了建立和銷燬執行緒的次數，每個工作執行緒都可以被重複利用，可執行多個任務
2. 可以根據系統的承受能力，調整執行緒池中工作線執行緒的數目，防止因為因為消耗過多的記憶體，而把伺服器累趴下(每個執行緒需要大約1MB記憶體，執行緒開的越多，消耗的記憶體也就越大，最後宕機)

 
本文以一個執行緒池的小例子，由淺入深到Tomcat執行緒池。例子如下，通過此例子，也能很好的學習和複習Java執行緒的API。
 
執行緒池類
 

package tast;
import java.util.LinkedList;
public class ThreadPool extends ThreadGroup {
 private boolean isClosed = false;  //執行緒池是否關閉
 private LinkedList workQueue;      //工作佇列
 private static int threadPoolID = 1;  //執行緒池的id
 public ThreadPool(int poolSize) {  //poolSize 表示執行緒池中的工作執行緒的數量

  super(threadPoolID + "");      //指定ThreadGroup的名稱
  setDaemon(true);               //繼承到的方法，設定是否守護執行緒池
  workQueue = new LinkedList();  //建立工作佇列
  for(int i = 0; i < poolSize; i++) {
   new WorkThread(i).start();   //建立並啟動工作執行緒,執行緒池數量是多少就建立多少個工作執行緒
  }
 }

 /** 向工作佇列中加入一個新任務,由工作執行緒去執行該任務*/
 public synchronized void execute(Runnable task) {
  if(isClosed) {
   throw new IllegalStateException();
  }
  if(task != null) {
   workQueue.add(task);//向佇列中加入一個任務
   notify();    //喚醒一個正在getTask()方法中待任務的工作執行緒
  }
 }

 /** 從工作佇列中取出一個任務,工作執行緒會呼叫此方法*/
 private synchronized Runnable getTask(int threadid) throws InterruptedException {
  while(workQueue.size() == 0) {
   if(isClosed) return null;
   System.out.println("工作執行緒"+threadid+"等待任務...");
   wait();    //如果工作佇列中沒有任務,就等待任務
  }
  System.out.println("工作執行緒"+threadid+"開始執行任務...");
  return (Runnable) workQueue.removeFirst(); //反回佇列中第一個元素,並從佇列中刪除
 }

 /** 關閉執行緒池 */
 public synchronized void closePool() {
  if(! isClosed) {
   waitFinish();        //等待工作執行緒執行完畢
   isClosed = true;
   workQueue.clear();  //清空工作佇列
   interrupt();   //中斷執行緒池中的所有的工作執行緒,此方法繼承自ThreadGroup類
  }
 }

 /** 等待工作執行緒把所有任務執行完畢*/
 public void waitFinish() {
  synchronized (this) {
   isClosed = true;
   notifyAll();   //喚醒所有還在getTask()方法中等待任務的工作執行緒
  }
  Thread[] threads = new Thread[activeCount()]; //activeCount() 返回該執行緒組中活動執行緒的估計值。
  int count = enumerate(threads); //enumerate()方法繼承自ThreadGroup類，根據活動執行緒的估計值獲得執行緒組中當前所有活動的工作執行緒
  for(int i =0; i < count; i++) { //等待所有工作執行緒結束
   try {
    threads[i].join(); //等待工作執行緒結束
   }catch(InterruptedException ex) {
    ex.printStackTrace();
   }
  }
 }

 /**
  * 內部類,工作執行緒,負責從工作佇列中取出任務,並執行
  * @author sunnylocus
  */
 private class WorkThread extends Thread {
  private int id;
  public WorkThread(int id) {
   //父類構造方法,將執行緒加入到當前ThreadPool執行緒組中
   super(ThreadPool.this,id+"");
   this.id =id;
  }
  public void run() {
   while(! isInterrupted()) {  //isInterrupted()方法繼承自Thread類，判斷執行緒是否被中斷
    Runnable task = null;
    try {
     task = getTask(id);  //取出任務
    }catch(InterruptedException ex) {
     ex.printStackTrace();
    }
    //如果getTask()返回null或者執行緒執行getTask()時被中斷，則結束此執行緒
    if(task == null) return;

    try {
     task.run();  //執行任務
    }catch(Throwable t) {
     t.printStackTrace();
    }
   }//  end while
  }//  end run
 }// end workThread
}
 

 
2.測試類
 

package tast;

 

public class ThreadPoolTest {

 public static void main(String[] args) throws InterruptedException {
  ThreadPool threadPool = new ThreadPool(3); //建立一個有個3工作執行緒的執行緒池
  Thread.sleep(500); //休眠500毫秒,以便讓執行緒池中的工作執行緒全部執行
  //執行任務
  for (int i = 0; i <=5 ; i++) { //建立6個任務
   threadPool.execute(createTask(i));
  }
  threadPool.waitFinish(); //等待所有任務執行完畢
  threadPool.closePool(); //關閉執行緒池

 }

 private static Runnable createTask(final int taskID) {
  return new Runnable() {
   public void run() {
   // System.out.println("Task" + taskID + "開始");
    System.out.println("Hello world");
   // System.out.println("Task" + taskID + "結束");
   }
  };
 }
}
 

 
結果返回：
 
工作執行緒0等待任務…
工作執行緒1等待任務…
工作執行緒2等待任務…
工作執行緒0開始執行任務…
Hello world
工作執行緒0開始執行任務…
Hello world
工作執行緒0開始執行任務…
Hello world
工作執行緒0開始執行任務…
Hello world
工作執行緒0開始執行任務…
Hello world
工作執行緒2開始執行任務…
Hello world

Tomcat是使用最廣的Java Web容器，功能強大，可擴充套件性強。最新版本的Tomcat（5.5.17）為了提高響應速度和效率，使用了Apache Portable Runtime（APR）作為最底層，使用了APR中包含Socket、緩衝池等多種技術，效能也提高了。APR也是Apache HTTPD的最底層。可想而知，同屬於ASF（Apache Software Foundation）中的成員，互補互用的情況還是很多的，雖然使用了不同的開發語言。
 

Tomcat 的執行緒池位於tomcat-util.jar檔案中，包含了兩種執行緒池方案。方案一：使用APR的Pool技術，使用了JNI；方案二：使用Java實現的ThreadPool。這裡介紹的是第二種。如果想了解APR的Pool技術，可以檢視APR的原始碼。
 
ThreadPool預設建立了5個執行緒，儲存在一個200維的執行緒陣列中，建立時就啟動了這些執行緒，當然在沒有請求時，它們都處理“等待”狀態（其實就是一個while迴圈，不停的等待notify）。如果有請求時，空閒執行緒會被喚醒執行使用者的請求。
 
具體的請求過程是： 服務啟動時，建立一個一維執行緒陣列（maxThread＝200個），並建立空閒執行緒(minSpareThreads＝5個)隨時等待使用者請求。 當有使用者請求時，呼叫 threadpool.runIt(ThreadPoolRunnable)方法，將一個需要執行的例項傳給ThreadPool中。其中使用者需要執行的例項必須實現ThreadPoolRunnable介面。 ThreadPool 首先查詢空閒的執行緒，如果有則用它執行要執行ThreadPoolRunnable；如果沒有空閒執行緒並且沒有超過maxThreads，就一次性建立 minSpareThreads個空閒執行緒；如果已經超過了maxThreads了，就等待空閒執行緒了。總之，要找到空閒的執行緒，以便用它執行例項。找到後，將該執行緒從執行緒陣列中移走。 接著喚醒已經找到的空閒執行緒，用它執行執行例項（ThreadPoolRunnable）。 執行完ThreadPoolRunnable後，就將該執行緒重新放到執行緒陣列中，作為空閒執行緒供後續使用。
 
由此可以看出，Tomcat的執行緒池實現是比較簡單的，ThreadPool.java也只有840行程式碼。用一個一維陣列儲存空閒的執行緒，每次以一個較小步伐（5個）建立空閒執行緒並放到執行緒池中。使用時從陣列中移走空閒的執行緒，用完後，再“歸還”給執行緒池。
 
ThreadPool提供的僅僅是執行緒池的實現，而如何使用執行緒池也是有很大學問的。讓我們看看Tomcat是如何使用ThreadPool的吧。
 
Tomcat有兩種EndPoint，分別是AprEndpoint和PoolTcpEndpoint。前者自己實現了一套執行緒池（其實這和Tomcat 老版本的方案是相同的，至今Tomcat中還保留著老版本的執行緒池，PoolTcpEndpoint也有類似的程式碼，通過“策略”可以選擇不同的執行緒池方案）。我們只關注PoolTcpEndpoint如何使用ThreadPool的。
 
首先，PoolTcpEndpoint建立了一個ThreadPoolRunnable例項——LeaderFollowerWorkerThread，實際上該例項就是接收（Accept）並處理（Process）使用者socket請求。接著將該例項放進ThreadPool中並執行，此時就可以接收使用者的請求了。
 
當有Socket請求時，LeaderFollowerWorkerThread首先獲得了Socket例項，注意此時LeaderFollowerWorkerThread並沒有急著處理該Socket，而是在響應Socket訊息前，再次將LeaderFollowerWorkerThread放進ThreadPool中，從而它（當然是另外一個執行緒了）可以繼續處理其他使用者的Socket請求；接著，擁有Socket的LeaderFollowerWorkerThread再來處理該使用者的Socket請求。
 
整個過程與傳統的處理使用者Socket請求是不同的，也和Tomcat老版本不同。傳統的處理方法是：有一個後臺執行的監聽執行緒負責統一處理接收（注意只是“接收”）Socket請求，當有新的Socket請求時，將它賦值給一個Worker執行緒（通常是喚醒該執行緒），並有後者處理Socket請求，監聽執行緒繼續等待其他Socket請求。所以整個過程中有一個從Listener到Worker切換的過程。
 
而新版本Tomcat很有創造性的使用了另外一種方法，正如前文所描述的，接收和處理某個使用者Socket請求的始終是由一個執行緒全程負責，沒有切換到其他執行緒處理，少了這種執行緒間的切換是否更有效率呢？我還不能確認。不過這種使用方式確實有別於傳統模式，有種耳目一新的感覺。