線程池是一種多線程處理形式，處理過程中將任務添加到隊列，然後在創建線程後自動啟動這些任務。線程池線程都是後台線程。每個線程都使用默認的堆棧大小，以默認的優先級運行，並處於多線程單元中。如果某個線程在托管代碼中空閒（如正在等待某個事件）,則線程池將插入另一個輔助線程來使所有處理器保持繁忙。如果所有線程池線程都始終保持繁忙，但隊列中包含掛起的工作，則線程池將在一段時間後創建另一個輔助線程但線程的數目永遠不會超過最大值。超過最大值的線程可以排隊，但他們要等到其他線程完成後才啟動。
組成部分
1、線程池管理器（ThreadPoolManager）:用於創建並管理線程池
2、工作線程（WorkThread）: 線程池中線程
3、任務接口（Task）:每個任務必須實現的接口，以供工作線程調度任務的執行。
4、任務隊列:用於存放沒有處理的任務。提供一種緩沖機制。
技術背景編輯
在面向對象編程中，創建和銷毀對象是很費時間的，因為創建一個對象要獲取內存資源或者其它更多資源。在Java中更是如此，虛擬機將試圖跟蹤每一個對象，以便能夠在對象銷毀後進行垃圾回收。所以提高服務程序效率的一個手段就是盡可能減少創建和銷毀對象的次數，特別是一些很耗資源的對象創建和銷毀。如何利用已有對象來服務就是一個需要解決的關鍵問題，其實這就是一些"池化資源"技術產生的原因。比如大家所熟悉的數據庫連接池正是遵循這一思想而產生的，本文將介紹的線程池技術同樣符合這一思想。
目前，一些著名的大公司都特別看好這項技術，並早已經在他們的產品中應用該技術。比如IBM的WebSphere，IONA的Orbix 2000在SUN的 Jini中，Microsoft的MTS（Microsoft Transaction Server 2.0），COM+等。
4功能編輯
應用程序可以有多個線程，這些線程在休眠狀態中需要耗費大量時間來等待事件發生。其他線程可能進入睡眠狀態，並且僅定期被喚醒以輪循更改或更新狀態信息，然後再次進入休眠狀態。為了簡化對這些線程的管理，.NET框架為每個進程提供了一個線程池，一個線程池有若干個等待操作狀態，當一個等待操作完成時，線程池中的輔助線程會執行回調函數。線程池中的線程由系統管理，程序員不需要費力於線程管理，可以集中精力處理應用程序任務。
應用范圍編輯1、需要大量的線程來完成任務，且完成任務的時間比較短。 WEB服務器完成網頁請求這樣的任務，使用線程池技術是非常合適的。因為單個任務小，而任務數量巨大，你可以想象一個熱門網站的點擊次數。 但對於長時間的任務，比如一個Telnet連接請求，線程池的優點就不明顯了。因為Telnet會話時間比線程的創建時間大多了。2、對性能要求苛刻的應用，比如要求服務器迅速響應客戶請求。3、接受突發性的大量請求，但不至於使服務器因此產生大量線程的應用。突發性大量客戶請求，在沒有線程池情況下，將產生大量線程，雖然理論上大部分操作系統線程數目最大值不是問題，短時間內產生大量線程可能使內存到達極限，並出現"OutOfMemory"的錯誤。
Java線程池原理及實現
簡單介紹
創建線程有兩種方式：繼承Thread或實現Runnable。Thread實現了Runnable接口，提供了一個空的run()方法，所以不論是繼承Thread還是實現Runnable，都要有自己的run()方法。
一個線程創建後就存在，調用start()方法就開始運行（執行run()方法），調用wait進入等待或調用sleep進入休眠期，順利運行完畢或休眠被中斷或運行過程中出現異常而退出。
wait和sleep比較：
sleep方法有：sleep(long millis)，sleep(long millis, long nanos)，調用sleep方法後，當前線程進入休眠期，暫停執行，但該線程繼續擁有監視資源的所有權。到達休眠時間後線程將繼續執行，直到完成。若在休眠期另一線程中斷該線程，則該線程退出。
wait方法有：wait()，wait(long timeout)，wait(long timeout, long nanos)，調用wait方法後，該線程放棄監視資源的所有權進入等待狀態；
wait()：等待有其它的線程調用notify()或notifyAll()進入調度狀態，與其它線程共同爭奪監視。wait()相當於wait(0)，wait(0, 0)。
wait(long timeout)：當其它線程調用notify()或notifyAll()，或時間到達timeout亳秒，或有其它某線程中斷該線程，則該線程進入調度狀態。
wait(long timeout, long nanos)：相當於wait(1000000*timeout + nanos)，只不過時間單位為納秒。
線程池：
多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閒置時間，增加處理器單元的吞吐能力。
假設一個服務器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。
如果：T1 + T3 遠大於 T2，則可以采用線程池，以提高服務器性能。
一個線程池包括以下四個基本組成部分：
1、線程池管理器（ThreadPool）：用於創建並管理線程池，包括 創建線程池，銷毀線程池，添加新任務；
2、工作線程（PoolWorker）：線程池中線程，在沒有任務時處於等待狀態，可以循環的執行任務；
3、任務接口（Task）：每個任務必須實現的接口，以供工作線程調度任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；
4、任務隊列（taskQueue）：用於存放沒有處理的任務。提供一種緩沖機制。
線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高服務器程序性能的。它把T1，T3分別安排在服務器程序的啟動和結束的時間段或者一些空閒的時間段，這樣在服務器程序處理客戶請求時，不會有T1，T3的開銷了。
線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目，看一個例子：
假設一個服務器一天要處理50000個請求，並且每個請求需要一個單獨的線程完成。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目，而如果服務器不利用線程池來處理這些請求則線程總數為50000。一般線程池大小是遠小於50000。所以利用線程池的服務器程序不會為了創建50000而在處理請求時浪費時間，從而提高效率。
/** 線程池類，工作線程作為其內部類 **/
import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import org.apache.log4j.Logger;
/**
* 線程池
* 創建線程池，銷毀線程池，添加新任務
*
* @author obullxl
*/
public final class ThreadPool {
private static Logger logger = Logger.getLogger(ThreadPool.class);
private static Logger taskLogger = Logger.getLogger("TaskLogger");
private static boolean debug = taskLogger.isDebugEnabled();
// private static boolean debug = taskLogger.isInfoEnabled();
/* 單例 */
private static ThreadPool instance = ThreadPool.getInstance();
public static final int SYSTEM_BUSY_TASK_COUNT = 150;
/* 默認池中線程數 */
public static int worker_num = 5;
/* 已經處理的任務數 */
private static int taskCounter = 0;
public static boolean systemIsBusy = false;
private static List<Task> taskQueue = Collections
.synchronizedList(new LinkedList<Task>());
/* 池中的所有線程 */
public PoolWorker[] workers;
private ThreadPool() {
workers = new PoolWorker[5];
for (int i = 0; i < workers.length; i++) {
workers[i] = new PoolWorker(i);
}
}
private ThreadPool(int pool_worker_num) {
worker_num = pool_worker_num;
workers = new PoolWorker[worker_num];
for (int i = 0; i < workers.length; i++) {
workers[i] = new PoolWorker(i);
}
}
public staticsynchronizedThreadPool getInstance() {
if (instance == null)
return new ThreadPool();
return instance;
}
/**
* 增加新的任務
* 每增加一個新任務，都要喚醒任務隊列
* @param newTask
*/
public void addTask(Task newTask) {
synchronized (taskQueue) {
newTask.setTaskId(++taskCounter);
newTask.setSubmitTime(new Date());
taskQueue.add(newTask);
/* 喚醒隊列, 開始執行 */
taskQueue.notifyAll();
}
logger.info("Submit Task<" + newTask.getTaskId() + ">: "
+ newTask.info());
}
/**
* 批量增加新任務
* 查看本欄目更多精彩內容：http://www.bianceng.cn/Programming/Java/
* @param taskes
*/
public void batchAddTask(Task[] taskes) {
if (taskes == null || taskes.length == 0) {
return;
}
synchronized (taskQueue) {
for (int i = 0; i < taskes.length; i++) {
if (taskes[i] == null) {
continue;
}
taskes[i].setTaskId(++taskCounter);
taskes[i].setSubmitTime(new Date());
taskQueue.add(taskes[i]);
}
/* 喚醒隊列, 開始執行 */
taskQueue.notifyAll();
}
for (int i = 0; i < taskes.length; i++) {
if (taskes[i] == null) {
continue;
}
logger.info("Submit Task<" + taskes[i].getTaskId() + ">: "
+ taskes[i].info());
}
}
/**
* 線程池信息
* @return
*/
public String getInfo() {
StringBuffer sb = new StringBuffer();
sb.append("\nTask Queue Size:" + taskQueue.size());
for (int i = 0; i < workers.length; i++) {
sb.append("\nWorker " + i + " is "
+ ((workers[i].isWaiting()) ? "Waiting." : "Running."));
}
return sb.toString();
}
/**
* 銷毀線程池
*/
public synchronized void destroy() {
for (int i = 0; i < worker_num; i++) {
workers[i].stopWorker();
workers[i] = null;
}
taskQueue.clear();
}
/**
* 池中工作線程
*
* @author obullxl
*/
private class PoolWorker extends Thread {
private int index = -1;
/* 該工作線程是否有效 */
private boolean isRunning = true;
/* 該工作線程是否可以執行新任務 */
private boolean isWaiting = true;
public PoolWorker(int index) {
this.index = index;
start();
}
public void stopWorker() {
this.isRunning = false;
}
public boolean isWaiting() {
return this.isWaiting;
}
/**
* 循環執行任務
* 這也許是線程池的關鍵所在
*/
public void run() {
while (isRunning) {
Task r = null;
synchronized (taskQueue) {
while (taskQueue.isEmpty()) {
try {
/* 任務隊列為空，則等待有新任務加入從而被喚醒 */
taskQueue.wait(20);
} catch (InterruptedException ie) {
logger.error(ie);
}
}
/* 取出任務執行 */
r = (Task) taskQueue.remove(0);
}
if (r != null) {
isWaiting = false;
try {
if (debug) {
r.setBeginExceuteTime(new Date());
taskLogger.debug("Worker<" + index
+ "> start execute Task<" + r.getTaskId() + ">");
if (r.getBeginExceuteTime().getTime()
- r.getSubmitTime().getTime() > 1000)
taskLogger.debug("longer waiting time. "
+ r.info() + ",<" + index + ">,time:"
+ (r.getFinishTime().getTime() - r
.getBeginExceuteTime().getTime()));
}
/* 該任務是否需要立即執行 */
if (r.needExecuteImmediate()) {
new Thread(r).start();
} else {
r.run();
}
if (debug) {
r.setFinishTime(new Date());
taskLogger.debug("Worker<" + index
+ "> finish task<" + r.getTaskId() + ">");
if (r.getFinishTime().getTime()
- r.getBeginExceuteTime().getTime() > 1000)
taskLogger.debug("longer execution time. "
+ r.info() + ",<" + index + ">,time:"
+ (r.getFinishTime().getTime() - r
.getBeginExceuteTime().getTime()));
}
} catch (Exception e) {
e.printStackTrace();
logger.error(e);
}
isWaiting = true;
r = null;
}
}
}
}
}
/** 任務接口類 **/
package org.ymcn.util;
import java.util.Date;
/**
* 所有任務接口
* 其他任務必須繼承訪類
*
* @author obullxl
*/
public abstract class Task implements Runnable {
// private static Logger logger = Logger.getLogger(Task.class);
/* 產生時間 */
private Date generateTime = null;
/* 提交執行時間 */
private Date submitTime = null;
/* 開始執行時間 */
private Date beginExceuteTime = null;
/* 執行完成時間 */
private Date finishTime = null;
private long taskId;
public Task() {
this.generateTime = new Date();
}
/**
* 任務執行入口
*/
public void run() {
/**
* 相關執行代碼
*
* beginTransaction();
*
* 執行過程中可能產生新的任務 subtask = taskCore();
*
* commitTransaction();
*
* 增加新產生的任務 ThreadPool.getInstance().batchAddTask(taskCore());
*/
}
/**
* 所有任務的核心 所以特別的業務邏輯執行之處
*
* @throws Exception
*/
public abstract Task[] taskCore() throws Exception;
/**
* 是否用到數據庫
*
* @return
*/
protected abstract boolean useDb();
/**
* 是否需要立即執行
*
* @return
*/
protected abstract boolean needExecuteImmediate();
/**
* 任務信息
*
* @return String
*/
public abstract String info();
public Date getGenerateTime() {
return generateTime;
}
public Date getBeginExceuteTime() {
return beginExceuteTime;
}
public void setBeginExceuteTime(Date beginExceuteTime) {
this.beginExceuteTime = beginExceuteTime;
}
public Date getFinishTime() {
return finishTime;
}
public void setFinishTime(Date finishTime) {
this.finishTime = finishTime;
}
public Date getSubmitTime() {
return submitTime;
}
public void setSubmitTime(Date submitTime) {
this.submitTime = submitTime;
}
public long getTaskId() {
return taskId;
}
public void setTaskId(long taskId) {
this.taskId = taskId;
}
}
