簡介
? ? ? ?我們使用線程的時候就去創建一個線程，這樣實現起來非常簡便，但是就會有一個問題：
? ? ? ?如果并發的線程數量很多，并且每個線程都是執行一個時間很短的任務就結束了，這樣頻繁創建線程就會大大降低系統的效率，因為頻繁創建線程和銷毀線程需要時間。
? ? ? ?那么有沒有一種辦法使得線程可以復用，就是執行完一個任務，并不被銷毀，而是可以繼續執行其他的任務？
? ? ? ?在Java中可以通過線程池來達到這樣的效果。今天我們就來詳細講解一下Java的線程池，首先我們從最核心的ThreadPoolExecutor類中的方法講起，然后再講述它的實現原理，接著給出了它的使用示例，最后討論了一下如何合理配置線程池的大小。
以下是本文的目錄大綱：
一、Java中的ThreadPoolExecutor類
二、深入剖析線程池實現原理
三、使用示例
四、為什么使用線程池
五、使用線程池的風險
六、有效使用線程池的準則
七、線程池的大小設置
一、Java中的ThreadPoolExecutor類
? ? ? ?java.uitl.concurrent.ThreadPoolExecutor類是線程池中最核心的一個類，因此如果要透徹地了解Java中的線程池，必須先了解這個類。下面我們來看一下ThreadPoolExecutor類的具體實現源碼。
在ThreadPoolExecutor類中提供了四個構造方法：
public class ThreadPoolExecutor extends AbstractExecutorService {.....public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue);public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);...
}? ? ? ?從上面的代碼可以得知，ThreadPoolExecutor繼承了AbstractExecutorService類，并提供了四個構造器，事實上，通過觀察每個構造器的源碼具體實現，發現前面三個構造器都是調用的第四個構造器進行的初始化工作。
?下面解釋下一下構造器中各個參數的含義：
- corePoolSize：核心池的大小，這個參數跟后面講述的線程池的實現原理有非常大的關系。在創建了線程池后，默認情況下，線程池中并沒有任何線程，而是等待有任務到來才創建線程去執行任務，除非調用了prestartAllCoreThreads()或者prestartCoreThread()方法，從這2個方法的名字就可以看出，是預創建線程的意思，即在沒有任務到來之前就創建corePoolSize個線程或者一個線程。默認情況下，在創建了線程池后，線程池中的線程數為0，當有任務來之后，就會創建一個線程去執行任務，當線程池中的線程數目達到corePoolSize后，就會把到達的任務放到緩存隊列當中；
- maximumPoolSize：線程池最大線程數，這個參數也是一個非常重要的參數，它表示在線程池中最多能創建多少個線程；
- keepAliveTime：表示線程沒有任務執行時最多保持多久時間會終止。默認情況下，只有當線程池中的線程數大于corePoolSize時，keepAliveTime才會起作用，直到線程池中的線程數不大于corePoolSize，即當線程池中的線程數大于corePoolSize時，如果一個線程空閑的時間達到keepAliveTime，則會終止，直到線程池中的線程數不超過corePoolSize。但是如果調用了allowCoreThreadTimeOut(boolean)方法，在線程池中的線程數不大于corePoolSize時，keepAliveTime參數也會起作用，直到線程池中的線程數為0；
- unit：參數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性：
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小時
TimeUnit.MINUTES; //分鐘
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //納秒- workQueue：一個阻塞隊列，用來存儲等待執行的任務，這個參數的選擇也很重要，會對線程池的運行過程產生重大影響，一般來說，這里的阻塞隊列有以下幾種選擇：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;? ? ? ?ArrayBlockingQueue和PriorityBlockingQueue使用較少，一般使用LinkedBlockingQueue和Synchronous。線程池的排隊策略與BlockingQueue有關。
- threadFactory：線程工廠，主要用來創建線程；
- handler：表示當拒絕處理任務時的策略，有以下四種取值：
ThreadPoolExecutor.AbortPolicy:丟棄任務并拋出RejectedExecutionException異常。
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不拋出異常。
ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，然后重新嘗試執行任務（重復此過程）
ThreadPoolExecutor.CallerRunsPolicy：由調用線程處理該任務 ? ? ? ?具體參數的配置與線程池的關系將在下一節講述。
? ? ? ?從上面給出的ThreadPoolExecutor類的代碼可以知道，ThreadPoolExecutor繼承了AbstractExecutorService，我們來看一下AbstractExecutorService的實現：
public abstract class AbstractExecutorService implements ExecutorService {protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };public Future<?> submit(Runnable task) {};public <T> Future<T> submit(Runnable task, T result) { };public <T> Future<T> submit(Callable<T> task) { };private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,boolean timed, long nanos)throws InterruptedException, ExecutionException, TimeoutException {};public <T> T invokeAny(Collection<? extends Callable<T>> tasks)throws InterruptedException, ExecutionException {};public <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException {};public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)throws InterruptedException {};public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException {};
}? ? ? ?AbstractExecutorService是一個抽象類，它實現了ExecutorService接口。
? ? ? ?我們接著看ExecutorService接口的實現：
public interface ExecutorService extends Executor {void shutdown();boolean isShutdown();boolean isTerminated();boolean awaitTermination(long timeout, TimeUnit unit)throws InterruptedException;<T> Future<T> submit(Callable<T> task);<T> Future<T> submit(Runnable task, T result);Future<?> submit(Runnable task);<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)throws InterruptedException;<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException;<T> T invokeAny(Collection<? extends Callable<T>> tasks)throws InterruptedException, ExecutionException;<T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;
}public interface Executor {void execute(Runnable command);
}? ? ? ?到這里，大家應該明白了ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor幾個之間的關系了。
- Executor是一個頂層接口，在它里面只聲明了一個方法execute(Runnable)，返回值為void，參數為Runnable類型，從字面意思可以理解，就是用來執行傳進去的任務的；
- 然后ExecutorService接口繼承了Executor接口，并聲明了一些方法：submit、invokeAll、invokeAny以及shutDown等；
- 抽象類AbstractExecutorService實現了ExecutorService接口，基本實現了ExecutorService中聲明的所有方法；
- 然后ThreadPoolExecutor繼承了類AbstractExecutorService。
? ? ? ?在ThreadPoolExecutor類中有幾個非常重要的方法：
execute()
submit()
shutdown()
shutdownNow()? ? ? ?execute()方法實際上是Executor中聲明的方法，在ThreadPoolExecutor進行了具體的實現，這個方法是ThreadPoolExecutor的核心方法，通過這個方法可以向線程池提交一個任務，交由線程池去執行。
? ? ? ?submit()方法是在ExecutorService中聲明的方法，在AbstractExecutorService就已經有了具體的實現，在ThreadPoolExecutor中并沒有對其進行重寫，這個方法也是用來向線程池提交任務的，但是它和execute()方法不同，它能夠返回任務執行的結果，去看submit()方法的實現，會發現它實際上還是調用的execute()方法，只不過它利用了Future來獲取任務執行結果（Future相關內容將在下一篇講述）。
? ? ? ?shutdown()和shutdownNow()是用來關閉線程池的。
? ? ? ?還有很多其他的方法：
? ? ? ?比如：getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等獲取與線程池相關屬性的方法，有興趣的朋友可以自行查閱API。
二、深入剖析線程池實現原理
在上一節我們從宏觀上介紹了ThreadPoolExecutor，下面我們來深入解析一下線程池的具體實現原理，將從下面幾個方面講解：
1、線程池狀態
2、任務的執行
3、線程池中的線程初始化
4、任務緩存隊列及排隊策略
5、任務拒絕策略
6、線程池的關閉
7、線程池容量的動態調整
1、線程池狀態
在ThreadPoolExecutor中定義了一個volatile變量，另外定義了幾個static final變量表示線程池的各個狀態：
volatile int runState;
static final int RUNNING = 0;
static final int SHUTDOWN = 1;
static final int STOP = 2;
static final int TERMINATED = 3;? ? ? ?runState：表示當前線程池的狀態，它是一個volatile變量用來保證線程之間的可見性；
下面的幾個static final變量表示runState可能的幾個取值：
? ? ? ?RUNNING：當創建線程池后，初始時，線程池處于RUNNING狀態；
? ? ? ?SHUTDOWN：如果調用了shutdown()方法，則線程池處于SHUTDOWN狀態，此時線程池不能夠接受新的任務，它會等待所有任務執行完畢；
? ? ? ?STOP：如果調用了shutdownNow()方法，則線程池處于STOP狀態，此時線程池不能接受新的任務，并且會去嘗試終止正在執行的任務；
? ? ? ?TERMINATED：當線程池處于SHUTDOWN或STOP狀態，并且所有工作線程已經銷毀，任務緩存隊列已經清空或執行結束后，線程池被設置為TERMINATED狀態。
2、任務的執行
? ? ? ?在了解將任務提交給線程池到任務執行完畢整個過程之前，我們先來看一下ThreadPoolExecutor類中其他的一些比較重要成員變量：
private final BlockingQueue<Runnable> workQueue; //任務緩存隊列，用來存放等待執行的任務
private final ReentrantLock mainLock = new ReentrantLock(); //線程池的主要狀態鎖，對線程池狀態（比如線程池大小//、runState等）的改變都要使用這個鎖
private final HashSet<Worker> workers = new HashSet<Worker>(); //用來存放工作集private volatile long keepAliveTime; //線程存活時間
private volatile boolean allowCoreThreadTimeOut; //是否允許為核心線程設置存活時間
private volatile int corePoolSize; //核心池的大小（即線程池中的線程數目大于這個參數時，提交的任務會被放進任務緩存隊列）
private volatile int maximumPoolSize; //線程池最大能容忍的線程數private volatile int poolSize; //線程池中當前的線程數private volatile RejectedExecutionHandler handler; //任務拒絕策略private volatile ThreadFactory threadFactory; //線程工廠，用來創建線程private int largestPoolSize; //用來記錄線程池中曾經出現過的最大線程數private long completedTaskCount; //用來記錄已經執行完畢的任務個數? ? ? ?每個變量的作用都已經標明出來了，這里要重點解釋一下corePoolSize、maximumPoolSize、largestPoolSize三個變量。
? ? ? ?corePoolSize在很多地方被翻譯成核心池大小，其實我的理解這個就是線程池的大小。舉個簡單的例子：
? ? ? ?假如有一個工廠，工廠里面有10個工人，每個工人同時只能做一件任務。
? ? ? ?因此只要當10個工人中有工人是空閑的，來了任務就分配給空閑的工人做；
? ? ? ?當10個工人都有任務在做時，如果還來了任務，就把任務進行排隊等待；
? ? ? ?如果說新任務數目增長的速度遠遠大于工人做任務的速度，那么此時工廠主管可能會想補救措施，比如重新招4個臨時工人進來；
? ? ? ?然后就將任務也分配給這4個臨時工人做；
? ? ? ?如果說著14個工人做任務的速度還是不夠，此時工廠主管可能就要考慮不再接收新的任務或者拋棄前面的一些任務了。
? ? ? ?當這14個工人當中有人空閑時，而新任務增長的速度又比較緩慢，工廠主管可能就考慮辭掉4個臨時工了，只保持原來的10個工人，畢竟請額外的工人是要花錢的。
? ? ? ?這個例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。
? ? ? ?也就是說corePoolSize就是線程池大小，maximumPoolSize在我看來是線程池的一種補救措施，即任務量突然過大時的一種補救措施。
? ? ? ?不過為了方便理解，在本文后面還是將corePoolSize翻譯成核心池大小。
? ? ? ?largestPoolSize只是一個用來起記錄作用的變量，用來記錄線程池中曾經有過的最大線程數目，跟線程池的容量沒有任何關系。
? ? ? ?下面我們進入正題，看一下任務從提交到最終執行完畢經歷了哪些過程。
? ? ? ?在ThreadPoolExecutor類中，最核心的任務提交方法是execute()方法，雖然通過submit也可以提交任務，但是實際上submit方法里面最終調用的還是execute()方法，所以我們只需要研究execute()方法的實現原理即可：
public void execute(Runnable command) {if (command == null)throw new NullPointerException();if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {if (runState == RUNNING && workQueue.offer(command)) {if (runState != RUNNING || poolSize == 0)ensureQueuedTaskHandled(command);}else if (!addIfUnderMaximumPoolSize(command))reject(command); // is shutdown or saturated}
}? ? ? ?上面的代碼可能看起來不是那么容易理解，下面我們一句一句解釋：
? ? ? ?首先，判斷提交的任務command是否為null，若是null，則拋出空指針異常；
? ? ? ?接著是這句，這句要好好理解一下：
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))? ? ? ?由于是或條件運算符，所以先計算前半部分的值，如果線程池中當前線程數不小于核心池大小，那么就會直接進入下面的if語句塊了。
? ? ? ?如果線程池中當前線程數小于核心池大小，則接著執行后半部分，也就是執行
addIfUnderCorePoolSize(command)? ? ? ?如果執行完addIfUnderCorePoolSize這個方法返回false，則繼續執行下面的if語句塊，否則整個方法就直接執行完畢了。
? ? ? ?如果執行完addIfUnderCorePoolSize這個方法返回false，然后接著判斷：
if (runState == RUNNING && workQueue.offer(command))addIfUnderMaximumPoolSize(command)? ? ? ?如果執行addIfUnderMaximumPoolSize方法失敗，則執行reject()方法進行任務拒絕處理。
? ? ? ?回到前面：
if (runState == RUNNING && workQueue.offer(command))if (runState != RUNNING || poolSize == 0)ensureQueuedTaskHandled(command)? ? ? ?進行應急處理，從名字可以看出是保證 添加到任務緩存隊列中的任務得到處理。
? ? ? ?我們接著看2個關鍵方法的實現：addIfUnderCorePoolSize和addIfUnderMaximumPoolSize：
private boolean addIfUnderCorePoolSize(Runnable firstTask) {Thread t = null;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {if (poolSize < corePoolSize && runState == RUNNING)t = addThread(firstTask); //創建線程去執行firstTask任務 } finally {mainLock.unlock();}if (t == null)return false;t.start();return true;
}t = addThread(firstTask);? ? ? ?這個方法也非常關鍵，傳進去的參數為提交的任務，返回值為Thread類型。然后接著在下面判斷t是否為空，為空則表明創建線程失敗（即poolSize>=corePoolSize或者runState不等于RUNNING），否則調用t.start()方法啟動線程。
? ? ? ?我們來看一下addThread方法的實現：
private Thread addThread(Runnable firstTask) {Worker w = new Worker(firstTask);Thread t = threadFactory.newThread(w); //創建一個線程，執行任務 if (t != null) {w.thread = t; //將創建的線程的引用賦值為w的成員變量 workers.add(w);int nt = ++poolSize; //當前線程數加1 if (nt > largestPoolSize)largestPoolSize = nt;}return t;
}? ? ? ?在addThread方法中，首先用提交的任務創建了一個Worker對象，然后調用線程工廠threadFactory創建了一個新的線程t，然后將線程t的引用賦值給了Worker對象的成員變量thread，接著通過workers.add(w)將Worker對象添加到工作集當中。
? ? ? ?下面我們看一下Worker類的實現：
private final class Worker implements Runnable {private final ReentrantLock runLock = new ReentrantLock();private Runnable firstTask;volatile long completedTasks;Thread thread;Worker(Runnable firstTask) {this.firstTask = firstTask;}boolean isActive() {return runLock.isLocked();}void interruptIfIdle() {final ReentrantLock runLock = this.runLock;if (runLock.tryLock()) {try {if (thread != Thread.currentThread())thread.interrupt();} finally {runLock.unlock();}}}void interruptNow() {thread.interrupt();}private void runTask(Runnable task) {final ReentrantLock runLock = this.runLock;runLock.lock();try {if (runState < STOP &&Thread.interrupted() &&runState >= STOP)boolean ran = false;beforeExecute(thread, task); //beforeExecute方法是ThreadPoolExecutor類的一個方法，沒有具體實現，用戶可以根據//自己需要重載這個方法和后面的afterExecute方法來進行一些統計信息，比如某個任務的執行時間等 try {task.run();ran = true;afterExecute(task, null);++completedTasks;} catch (RuntimeException ex) {if (!ran)afterExecute(task, ex);throw ex;}} finally {runLock.unlock();}}public void run() {try {Runnable task = firstTask;firstTask = null;while (task != null || (task = getTask()) != null) {runTask(task);task = null;}} finally {workerDone(this); //當任務隊列中沒有任務時，進行清理工作 }}
}Thread t = new Thread(w);? ? ? ?相當于傳進去了一個Runnable任務，在線程t中執行這個Runnable。
? ? ? ?既然Worker實現了Runnable接口，那么自然最核心的方法便是run()方法了：
public void run() {try {Runnable task = firstTask;firstTask = null;while (task != null || (task = getTask()) != null) {runTask(task);task = null;}} finally {workerDone(this);}
}Runnable getTask() {for (;;) {try {int state = runState;if (state > SHUTDOWN)return null;Runnable r;if (state == SHUTDOWN) // Help drain queuer = workQueue.poll();else if (poolSize > corePoolSize || allowCoreThreadTimeOut) //如果線程數大于核心池大小或者允許為核心池線程設置空閑時間，//則通過poll取任務，若等待一定的時間取不到任務，則返回nullr = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);elser = workQueue.take();if (r != null)return r;if (workerCanExit()) { //如果沒取到任務，即r為null，則判斷當前的worker是否可以退出if (runState >= SHUTDOWN) // Wake up othersinterruptIdleWorkers(); //中斷處于空閑狀態的workerreturn null;}// Else retry} catch (InterruptedException ie) {// On interruption, re-check runState}}
}? ? ? ?在getTask中，先判斷當前線程池狀態，如果runState大于SHUTDOWN（即為STOP或者TERMINATED），則直接返回null。
? ? ? ?如果runState為SHUTDOWN或者RUNNING，則從任務緩存隊列取任務。
? ? ? ?如果當前線程池的線程數大于核心池大小corePoolSize或者允許為核心池中的線程設置空閑存活時間，則調用poll(time,timeUnit)來取任務，這個方法會等待一定的時間，如果取不到任務就返回null。
? ? ? ?然后判斷取到的任務r是否為null，為null則通過調用workerCanExit()方法來判斷當前worker是否可以退出，我們看一下workerCanExit()的實現：
private boolean workerCanExit() {final ReentrantLock mainLock = this.mainLock;mainLock.lock();boolean canExit;//如果runState大于等于STOP，或者任務緩存隊列為空了//或者 允許為核心池線程設置空閑存活時間并且線程池中的線程數目大于1try {canExit = runState >= STOP ||workQueue.isEmpty() ||(allowCoreThreadTimeOut &&poolSize > Math.max(1, corePoolSize));} finally {mainLock.unlock();}return canExit;
}void interruptIdleWorkers() {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {for (Worker w : workers) //實際上調用的是worker的interruptIfIdle()方法w.interruptIfIdle();} finally {mainLock.unlock();}
}void interruptIfIdle() {final ReentrantLock runLock = this.runLock;if (runLock.tryLock()) { //注意這里，是調用tryLock()來獲取鎖的，因為如果當前worker正在執行任務，鎖已經被獲取了，是無法獲取到鎖的//如果成功獲取了鎖，說明當前worker處于空閑狀態try {if (thread != Thread.currentThread()) thread.interrupt();} finally {runLock.unlock();}}
}? ? ? ?這里有一個非常巧妙的設計方式，假如我們來設計線程池，可能會有一個任務分派線程，當發現有線程空閑時，就從任務緩存隊列中取一個任務交給空閑線程執行。但是在這里，并沒有采用這樣的方式，因為這樣會要額外地對任務分派線程進行管理，無形地會增加難度和復雜度，這里直接讓執行完任務的線程去任務緩存隊列里面取任務來執行。
? ? ? ? 我們再看addIfUnderMaximumPoolSize方法的實現，這個方法的實現思想和addIfUnderCorePoolSize方法的實現思想非常相似，唯一的區別在于addIfUnderMaximumPoolSize方法是在線程池中的線程數達到了核心池大小并且往任務隊列中添加任務失敗的情況下執行的：
private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {Thread t = null;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {if (poolSize < maximumPoolSize && runState == RUNNING)t = addThread(firstTask);} finally {mainLock.unlock();}if (t == null)return false;t.start();return true;
}? ? ? ?看到沒有，其實它和addIfUnderCorePoolSize方法的實現基本一模一樣，只是if語句判斷條件中的poolSize < maximumPoolSize不同而已。
到這里，大部分朋友應該對任務提交給線程池之后到被執行的整個過程有了一個基本的了解，下面總結一下：
? ? ? ?1）首先，要清楚corePoolSize和maximumPoolSize的含義；
? ? ? ?2）其次，要知道Worker是用來起到什么作用的；
? ? ? ?3）要知道任務提交給線程池之后的處理策略，這里總結一下主要有4點：
- 如果當前線程池中的線程數目小于corePoolSize，則每來一個任務，就會創建一個線程去執行這個任務；
- 如果當前線程池中的線程數目>=corePoolSize，則每來一個任務，會嘗試將其添加到任務緩存隊列當中，若添加成功，則該任務會等待空閑線程將其取出去執行；若添加失敗（一般來說是任務緩存隊列已滿），則會嘗試創建新的線程去執行這個任務；
- 如果當前線程池中的線程數目達到maximumPoolSize，則會采取任務拒絕策略進行處理；
- 如果線程池中的線程數量大于 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止，直至線程池中的線程數目不大于corePoolSize；如果允許為核心池中的線程設置存活時間，那么核心池中的線程空閑時間超過keepAliveTime，線程也會被終止。
3、線程池中的線程初始化
? ? ? ?默認情況下，創建線程池之后，線程池中是沒有線程的，需要提交任務之后才會創建線程。
在實際中如果需要線程池創建之后立即創建線程，可以通過以下兩個方法辦到：
- prestartCoreThread()：初始化一個核心線程；
- prestartAllCoreThreads()：初始化所有核心線程。
下面是這2個方法的實現：
public boolean prestartCoreThread() {return addIfUnderCorePoolSize(null); //注意傳進去的參數是null
}public int prestartAllCoreThreads() {int n = 0;while (addIfUnderCorePoolSize(null))//注意傳進去的參數是null++n;return n;
}r = workQueue.take();4、任務緩存隊列及排隊策略
? ? ? ?在前面我們多次提到了任務緩存隊列，即workQueue，它用來存放等待執行的任務。
workQueue的類型為BlockingQueue<Runnable>，通常可以取下面三種類型：
? ? ? ?1）ArrayBlockingQueue：基于數組的先進先出隊列，此隊列創建時必須指定大小；
? ? ? ?2）LinkedBlockingQueue：基于鏈表的先進先出隊列，如果創建時沒有指定此隊列大小，則默認為Integer.MAX_VALUE；
? ? ? ?3）synchronousQueue：這個隊列比較特殊，它不會保存提交的任務，而是將直接新建一個線程來執行新來的任務。
5、任務拒絕策略
? ? ? ?當線程池的任務緩存隊列已滿并且線程池中的線程數目達到maximumPoolSize，如果還有任務到來就會采取任務拒絕策略，通常有以下四種策略：
ThreadPoolExecutor.AbortPolicy:丟棄任務并拋出RejectedExecutionException異常。
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不拋出異常。
ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，然后重新嘗試執行任務（重復此過程）
ThreadPoolExecutor.CallerRunsPolicy：由調用線程處理該任務6、線程池的關閉
ThreadPoolExecutor提供了兩個方法，用于線程池的關閉，分別是shutdown()和shutdownNow()，其中：
- shutdown()：不會立即終止線程池，而是要等所有任務緩存隊列中的任務都執行完后才終止，但再也不會接受新的任務
- shutdownNow()：立即終止線程池，并嘗試打斷正在執行的任務，并且清空任務緩存隊列，返回尚未執行的任務
7、線程池容量的動態調整
ThreadPoolExecutor提供了動態調整線程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()
- setCorePoolSize：設置核心池大小
- setMaximumPoolSize：設置線程池最大能創建的線程數目大小
? ? ? ?當上述參數從小變大時，ThreadPoolExecutor進行線程賦值，還可能立即創建新的線程來執行任務。
三、使用示例
? ? ? ?前面我們討論了關于線程池的實現原理，這一節我們來看一下它的具體使用：
public class Test {public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(5));for(int i=0;i<15;i++){MyTask myTask = new MyTask(i);executor.execute(myTask);System.out.println("線程池中線程數目："+executor.getPoolSize()+"，隊列中等待執行的任務數目："+executor.getQueue().size()+"，已執行玩別的任務數目："+executor.getCompletedTaskCount());}executor.shutdown();}
}class MyTask implements Runnable {private int taskNum;public MyTask(int num) {this.taskNum = num;}@Overridepublic void run() {System.out.println("正在執行task "+taskNum);try {Thread.currentThread().sleep(4000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("task "+taskNum+"執行完畢");}
}
正在執行task 0
線程池中線程數目：1，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
線程池中線程數目：2，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 1
線程池中線程數目：3，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 2
線程池中線程數目：4，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 3
線程池中線程數目：5，隊列中等待執行的任務數目：0，已執行玩別的任務數目：0
正在執行task 4
線程池中線程數目：5，隊列中等待執行的任務數目：1，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：2，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：3，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：4，已執行玩別的任務數目：0
線程池中線程數目：5，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
線程池中線程數目：6，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 10
線程池中線程數目：7，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 11
線程池中線程數目：8，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 12
線程池中線程數目：9，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 13
線程池中線程數目：10，隊列中等待執行的任務數目：5，已執行玩別的任務數目：0
正在執行task 14
task 3執行完畢
task 0執行完畢
task 2執行完畢
task 1執行完畢
正在執行task 8
正在執行task 7
正在執行task 6
正在執行task 5
task 4執行完畢
task 10執行完畢
task 11執行完畢
task 13執行完畢
task 12執行完畢
正在執行task 9
task 14執行完畢
task 8執行完畢
task 5執行完畢
task 7執行完畢
task 6執行完畢
task 9執行完畢? ? ? ?從執行結果可以看出，當線程池中線程的數目大于5時，便將任務放入任務緩存隊列里面，當任務緩存隊列滿了之后，便創建新的線程。如果上面程序中，將for循環中改成執行20個任務，就會拋出任務拒絕異常了。
? ? ? ?不過在java doc中，并不提倡我們直接使用ThreadPoolExecutor，而是使用Executors類中提供的幾個靜態方法來創建線程池：
Executors.newCachedThreadPool(); //創建一個緩沖池，緩沖池容量大小為Integer.MAX_VALUE
Executors.newSingleThreadExecutor(); //創建容量為1的緩沖池
Executors.newFixedThreadPool(int); //創建固定容量大小的緩沖池
Executors.newScheduledThreadPool(int) //創建一個定長的線程池，而且支持定時的以及周期性的任務執行，支持定時及周期性任務執行。下面是這四個靜態方法的具體實現；
public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
}public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);
}? ? ? ?從它們的具體實現來看，它們實際上也是調用了ThreadPoolExecutor，只不過參數都已配置好了。
? ? ? ?1、newFixedThreadPool創建的線程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；
? ? ? ?2、newSingleThreadExecutor將corePoolSize和maximumPoolSize都設置為1，也使用的LinkedBlockingQueue；
? ? ? ?3、newCachedThreadPool將corePoolSize設置為0，將maximumPoolSize設置為Integer.MAX_VALUE，使用的SynchronousQueue，也就是說來了任務就創建線程運行，當線程空閑超過60秒，就銷毀線程。
? ? ? ?4、newScheduledThreadPool實例化了一個ScheduledThreadPoolExecutor對象，該類繼承了ThreadPoolExecutor，其中maximumPoolSize設置為Integer.MAX_VALUE，使用的是DelayedWorkQueue。
? ? ? ?實際中，如果Executors提供的四個靜態方法能滿足要求，就盡量使用它提供的四個方法，因為自己去手動配置ThreadPoolExecutor的參數有點麻煩，要根據實際任務的類型和數量來進行配置。
? ? ? ?另外，如果ThreadPoolExecutor達不到要求，可以自己繼承ThreadPoolExecutor類進行重寫。
1、newFixedThreadPool
? ? ? ?創建一個指定工作線程數量的線程池。每當提交一個任務就創建一個工作線程，如果工作線程數量達到線程池初始的最大數，則將提交的任務存入到池隊列中。
? ? ? ?FixedThreadPool是一個典型且優秀的線程池，它具有線程池提高程序效率和節省創建線程時所耗的開銷的優點。但是，在線程池空閑時，即線程池中沒有可運行任務時，它不會釋放工作線程，還會占用一定的系統資源。
示例代碼如下：
public class ThreadPoolTest {public static void main(String[] args) {ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);for (int i = 0; i < 10; i++) {final int index = i;fixedThreadPool.execute(new Runnable() {public void run() {try {System.out.println(index);Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}});}}
}? ? ? ?定長線程池的大小最好根據系統資源進行設置如Runtime.getRuntime().availableProcessors()。
2、newSingleThreadExecutor
? ? ? ?創建一個單線程化的Executor，即只創建唯一的工作者線程來執行任務，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO,?優先級)執行。如果這個線程異常結束，會有另一個取代它，保證順序執行。單工作線程最大的特點是可保證順序地執行各個任務，并且在任意給定的時間不會有多個線程是活動的。
示例代碼如下：
public class ThreadPoolTest {public static void main(String[] args) {ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {final int index = i;singleThreadExecutor.execute(new Runnable() {public void run() {try {System.out.println(index);Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}});}}
}3、newCachedThreadPool
? ? ? ?創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
這種類型的線程池特點是：
- 工作線程的創建數量幾乎沒有限制(其實也有限制的,數目為Interger. MAX_VALUE),?這樣可靈活的往線程池中添加線程。
- 如果長時間沒有往線程池中提交任務，即如果工作線程空閑了指定的時間(默認為1分鐘)，則該工作線程將自動終止。終止后，如果你又提交了新的任務，則線程池重新創建一個工作線程。
- 在使用CachedThreadPool時，一定要注意控制任務的數量，否則，由于大量線程同時運行，很有會造成系統癱瘓。
示例代碼如下：
public class ThreadPoolTest {public static void main(String[] args) {ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {final int index = i;try {Thread.sleep(index * 1000);} catch (InterruptedException e) {e.printStackTrace();}cachedThreadPool.execute(new Runnable() {public void run() {System.out.println(index);}});}}
}
? ? ? ?創建一個定長的線程池，而且支持定時的以及周期性的任務執行，支持定時及周期性任務執行。
延遲3秒執行，延遲執行示例代碼如下：
public class ThreadPoolTest {public static void main(String[] args) {ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);scheduledThreadPool.schedule(new Runnable() {public void run() {System.out.println("delay 3 seconds");}}, 3, TimeUnit.SECONDS);}
}
public class ThreadPoolTest {public static void main(String[] args) {ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);scheduledThreadPool.scheduleAtFixedRate(new Runnable() {public void run() {System.out.println("delay 1 seconds, and excute every 3 seconds");}}, 1, 3, TimeUnit.SECONDS);}
}四、為什么使用線程池
? ? ? ?諸如?Web?服務器、數據庫服務器、文件服務器或郵件服務器之類的許多服務器應用程序都面向處理來自某些遠程來源的大量短小的任務。請求以某種方式到達服務器，這種方式可能是通過網絡協議（例如?HTTP、FTP?或?POP）、通過?JMS?隊列或者可能通過輪詢數據庫。不管請求如何到達，服務器應用程序中經常出現的情況是：單個任務處理的時間很短而請求的數目卻是巨大的。
? ? ? ?構建服務器應用程序的一個簡單模型是：每當一個請求到達就創建一個新線程，然后在新線程中為請求服務。實際上對于原型開發這種方法工作得很好，但如果試圖部署以這種方式運行的服務器應用程序，那么這種方法的嚴重不足就很明顯。每個請求對應一個線程（thread-per-request）方法的不足之一是：為每個請求創建一個新線程的開銷很大；為每個請求創建新線程的服務器在創建和銷毀線程上花費的時間和消耗的系統資源要比花在處理實際的用戶請求的時間和資源更多。
? ? ? ?除了創建和銷毀線程的開銷之外，活動的線程也消耗系統資源。在一個?JVM?里創建太多的線程可能會導致系統由于過度消耗內存而用完內存或“切換過度”。為了防止資源不足，服務器應用程序需要一些辦法來限制任何給定時刻處理的請求數目。
? ? ? ?線程池為線程生命周期開銷問題和資源不足問題提供了解決方案。通過對多個任務重用線程，線程創建的開銷被分攤到了多個任務上。其好處是，因為在請求到達時線程已經存在，所以無意中也消除了線程創建所帶來的延遲。這樣，就可以立即為請求服務，使應用程序響應更快。而且，通過適當地調整線程池中的線程數目，也就是當請求的數目超過某個閾值時，就強制其它任何新到的請求一直等待，直到獲得一個線程來處理為止，從而可以防止資源不足。
五、使用線程池的風險
? ? ? ?雖然線程池是構建多線程應用程序的強大機制，但使用它并不是沒有風險的。用線程池構建的應用程序容易遭受任何其它多線程應用程序容易遭受的所有并發風險，諸如同步錯誤和死鎖，它還容易遭受特定于線程池的少數其它風險，諸如與池有關的死鎖、資源不足和線程泄漏。
1、死鎖
? ? ? ?任何多線程應用程序都有死鎖風險。當一組進程或線程中的每一個都在等待一個只有該組中另一個進程才能引起的事件時，我們就說這組進程或線程?死鎖了。死鎖的最簡單情形是：線程?A?持有對象?X?的獨占鎖，并且在等待對象?Y?的鎖，而線程?B?持有對象?Y?的獨占鎖，卻在等待對象?X?的鎖。除非有某種方法來打破對鎖的等待（Java?鎖定不支持這種方法），否則死鎖的線程將永遠等下去。
? ? ? ?雖然任何多線程程序中都有死鎖的風險，但線程池卻引入了另一種死鎖可能，在那種情況下，所有池線程都在執行已阻塞的等待隊列中另一任務的執行結果的任務，但這一任務卻因為沒有未被占用的線程而不能運行。當線程池被用來實現涉及許多交互對象的模擬，被模擬的對象可以相互發送查詢，這些查詢接下來作為排隊的任務執行，查詢對象又同步等待著響應時，會發生這種情況。
2、資源不足
? ? ? ?線程池的一個優點在于：相對于其它替代調度機制（有些我們已經討論過）而言，它們通常執行得很好。但只有恰當地調整了線程池大小時才是這樣的。線程消耗包括內存和其它系統資源在內的大量資源。除了?Thread?對象所需的內存之外，每個線程都需要兩個可能很大的執行調用堆棧。除此以外，JVM?可能會為每個?Java?線程創建一個本機線程，這些本機線程將消耗額外的系統資源。最后，雖然線程之間切換的調度開銷很小，但如果有很多線程，環境切換也可能嚴重地影響程序的性能。
? ? ? ?如果線程池太大，那么被那些線程消耗的資源可能嚴重地影響系統性能。在線程之間進行切換將會浪費時間，而且使用超出比您實際需要的線程可能會引起資源匱乏問題，因為池線程正在消耗一些資源，而這些資源可能會被其它任務更有效地利用。除了線程自身所使用的資源以外，服務請求時所做的工作可能需要其它資源，例如JDBC?連接、套接字或文件。這些也都是有限資源，有太多的并發請求也可能引起失效，例如不能分配?JDBC?連接。
3、并發錯誤
? ? ? ?線程池和其它排隊機制依靠使用?wait()?和?notify()?方法，這兩個方法都難于使用。如果編碼不正確，那么可能丟失通知，導致線程保持空閑狀態，盡管隊列中有工作要處理。使用這些方法時，必須格外小心。而最好使用現有的、已經知道能工作的實現，例如?util.concurrent?包。
4、線程泄漏
? ? ? ?各種類型的線程池中一個嚴重的風險是線程泄漏，當從池中除去一個線程以執行一項任務，而在任務完成后該線程卻沒有返回池時，會發生這種情況。發生線程泄漏的一種情形出現在任務拋出一個?RuntimeException?或一個?Error?時。如果池類沒有捕捉到它們，那么線程只會退出而線程池的大小將會永久減少一個。當這種情況發生的次數足夠多時，線程池最終就為空，而且系統將停止，因為沒有可用的線程來處理任務。
? ? ? ?有些任務可能會永遠等待某些資源或來自用戶的輸入，而這些資源又不能保證變得可用，用戶可能也已經回家了，諸如此類的任務會永久停止，而這些停止的任務也會引起和線程泄漏同樣的問題。如果某個線程被這樣一個任務永久地消耗著，那么它實際上就被從池除去了。對于這樣的任務，應該要么只給予它們自己的線程，要么只讓它們等待有限的時間。
5、請求過載
? ? ? ?僅僅是請求就壓垮了服務器，這種情況是可能的。在這種情形下，我們可能不想將每個到來的請求都排隊到我們的工作隊列，因為排在隊列中等待執行的任務可能會消耗太多的系統資源并引起資源缺乏。在這種情形下決定如何做取決于您自己；在某些情況下，您可以簡單地拋棄請求，依靠更高級別的協議稍后重試請求，您也可以用一個指出服務器暫時很忙的響應來拒絕請求。
六、有效使用線程池的準則
只要您遵循幾條簡單的準則，線程池可以成為構建服務器應用程序的極其有效的方法：
- 不要對那些同步等待其它任務結果的任務排隊。這可能會導致上面所描述的那種形式的死鎖，在那種死鎖中，所有線程都被一些任務所占用，這些任務依次等待排隊任務的結果，而這些任務又無法執行，因為所有的線程都很忙。
- 在為時間可能很長的操作使用合用的線程時要小心。如果程序必須等待諸如?I/O?完成這樣的某個資源，那么請指定最長的等待時間，以及隨后是失效還是將任務重新排隊以便稍后執行。這樣做保證了：通過將某個線程釋放給某個可能成功完成的任務，從而將最終取得某些進展。
- 理解任務。要有效地調整線程池大小，您需要理解正在排隊的任務以及它們正在做什么。它們是?CPU?限制的（CPU-bound）嗎？它們是?I/O?限制的（I/O-bound）嗎？您的答案將影響您如何調整應用程序。如果您有不同的任務類，這些類有著截然不同的特征，那么為不同任務類設置多個工作隊列可能會有意義，這樣可以相應地調整每個池。
七、線程池的大小設置
? ? ? ?本節來討論一個比較重要的話題：如何合理配置線程池大小，僅供參考。
? ? ? ?一般需要根據任務的類型來配置線程池大小：
? ? ? ?1、如果是CPU密集型任務，就需要盡量壓榨CPU，參考值可以設為?NCPU+1
? ? ? ?2、如果是IO密集型任務，參考值可以設置為2*NCPU
? ? ? ?當然，這只是一個參考值，具體的設置還需要根據實際情況進行調整，比如可以先將線程池大小設置為參考值，再觀察任務運行情況和系統負載、資源利用率來進行適當調整。
? ? ? ?調整線程池的大小基本上就是避免兩類錯誤：線程太少或線程太多。幸運的是，對于大多數應用程序來說，太多和太少之間的余地相當寬。
? ? ? ?請回憶：在應用程序中使用線程有兩個主要優點，盡管在等待諸如?I/O?的慢操作，但允許繼續進行處理，并且可以利用多處理器。在運行于具有?N?個處理器機器上的計算限制的應用程序中，在線程數目接近?N?時添加額外的線程可能會改善總處理能力，而在線程數目超過?N?時添加額外的線程將不起作用。事實上，太多的線程甚至會降低性能，因為它會導致額外的環境切換開銷。
? ? ? ?線程池的最佳大小取決于可用處理器的數目以及工作隊列中的任務的性質。若在一個具有?N?個處理器的系統上只有一個工作隊列，其中全部是計算性質的任務，在線程池具有?N?或?N+1?個線程時一般會獲得最大的?CPU?利用率。
? ? ? ?對于那些可能需要等待?I/O?完成的任務（例如，從套接字讀取?HTTP?請求的任務），需要讓池的大小超過可用處理器的數目，因為并不是所有線程都一直在工作。通過使用概要分析，您可以估計某個典型請求的等待時間（WT）與服務時間（ST）之間的比例。如果我們將這一比例稱之為?WT/ST，那么對于一個具有?N?個處理器的系統，需要設置大約?N*(1+WT/ST)?個線程來保持處理器得到充分利用。
? ? ? ?處理器利用率不是調整線程池大小過程中的唯一考慮事項。隨著線程池的增長，您可能會碰到調度程序、可用內存方面的限制，或者其它系統資源方面的限制，例如套接字、打開的文件句柄或數據庫連接等的數目。
