本文轉載自個人掘金博客：https://juejin.im/post/5ee75a2b6fb9a0480170718f
線程池的好處
Java中的線程池是運用場景最多的併發框架，幾乎所有需要異步或併發執行任務的程序都可以使用線程池。在開發過程中，合理地使用線程池，相對於單線程串行處理（Serial Processing）和爲每一個任務分配一個新線程（One Task One New Thread）的做法能夠帶來3個好處。
- 降低資源消耗。通過重複利用已創建的線程降低線程創建和銷燬造成的消耗。
- 提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
- 提高線程的可管理性。線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。但是，要做到合理利用線程池，必須對其實現原理了如指掌。
線程池的實現原理
下面所有的介紹都是基於JDK 1.8源碼。
架構設計
Java中的線程池核心實現類是ThreadPoolExecutor。這個類的設計是繼承了AbstractExecutorService抽象類和實現了ExecutorService，Executor兩個接口，關係大致如下圖所示：
下面將從頂向下逐個介紹這個4個接口與類。
Executor
頂層接口Executor提供了一種將任務提交和每個任務的執行機制(包括線程使用的細節以及線程調度等)解耦分開的方法。使用Executor可以避免顯式的創建線程。例如，對於一系列的任務，你可能會使用下列這種方式來代替new Thread(new(RunnableTask())).start()的方式：
Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
Executor接口提供了一個接口方法，用來在未來的某段時間執行指定的任務。指定的任務
- 可能由一個新創建的線程執行；
- 可能由一個線程池中空閒的線程執行；
- 也可能由方法的調用線程執行。
這些可能執行方式都取決於Executor接口實現類的設計或實現方式。
public interface Executor {
void execute(Runnable command);
}
Serial Processing
事實上，Executor接口並沒有嚴格的要求線程的執行需要異步進行。最簡單的接口實現方法是，將所有的任務以調用方法的線程執行。
class DirectExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}
這種實際上就是上面提到的Serial Processing的方式。假設，我們現在以這種方式去實現一個響應請求的服務器應用。那麼，這種實現方式雖然在理論上是正確的。
-
但是其性能卻非常差，因爲它每次只能響應處理一個請求。如果有大量請求則只能串行響應。
-
同時，如果服務器響應邏輯裏面有文件I/O或者數據庫操作，服務器需要等待這些操作完成才能繼續執行。這個時候如果阻塞的時間過長，服務器資源利用率就很低。這樣，在等待過程中，服務器CPU將處於空閒狀態。
綜上，這種Serial Processing的方式方式就會有無法快速響應問題和低吞吐率問題。
One Task One New Thread
不過，更典型的實現方式是，任務由一些其他的線程執行而不是方法調用的線程執行。例如，下面的Executor的實現方法是對於每一個任務都新建一個線程去執行。
class ThreadPerTaskExecutor implements Executor {
public void execute(Runnable r) {
new Thread(r).start();
}
}
這種方式實際上就是上面提到的One Task One New Thread的方式，這種無限創建線程的方法也有很多問題。
- 線程生命週期的開銷非常高。如果有大量任務需要執行，那麼就需要創建大量線程。這樣就會造成線程生命週期的創建和銷燬的開銷非常大。
- 資源消耗。活躍的線程會消耗系統資源，尤其是內存。如果，已經有足夠多的線程使所有的CPU保持忙碌狀態，那麼在創建更多的線程反而會降低性能。最簡單的例子是，一個4核的CPU機器，對於100個任務創建100個線程去執行。
- 穩定性。可創建線程的數量上存在一個限制。這個限制受JVM啓動參數，棧大小以及底層操作系統對線程的限制等因素。超過了這個限制，就可能拋出OutOfMemoryError異常。
ExecutorService
ExecutorService接口是繼承自Executor接口，並增加了一些接口方法。接口也可以繼承？以前沒注意，現在學習到了。這裏介紹下接口繼承的語義：
-
接口Executor有execute(Runnable)方法，接口ExecutorService繼承Executor，不用複寫Executor的方法。只需要，寫自己的方法(業務)即可。
-
當一個類ThreadPoolExecutor要實現ExecutorService接口的時候，需要實現ExecutorService和Executor兩個接口的方法。
ExecutorService大致新增了2類接口方法：
-
ExecutorService的關閉方法。對於線程池實現，這些方法的具體實現在ThreadPoolExecutor裏面。
-
擴充異步執行任務的方法。對於線程池實現，用的這類方法都是AbstractExecutorService抽象類裏面實現的模板方法。
AbstractExecutorService
抽象類AbstractExecutorService提供了ExecutorService接口類中各種submit異步執行方法的實現，這些方法與Executor.execute(Runnable)相比，它們都是有返回值的。同時，這些方法的實現的最終都是調用ThreadPoolExecutor類中實現的execute(Runnable)方法。
儘管說submit方法能提供線程執行的返回值，但只有實現了Callable纔會有返回值，而實現Runnable的返回值是null。
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
除此之外，這個抽象類中還有ExecutorService接口類中invokeAny和invokeAll方法的實現。這裏就只是簡單介紹下這2個種方法的語義。
invokeAny
- invokeAny() 接收一個包含 Callable 對象的集合作爲參數。調用該方法不會返回 Future 對象，而是返回集合中某一個Callable對象的運行結果。
- 這個方法沒法保證調用之後返回的結果是哪一個Callable，只知道它是這些 Callable 中一個執行結束的Callable 對象。
invokeAll
- invokeAll接受一個包含 Callable 對象的集合作爲參數。調用該方法會返回一個Future 對象的列表，對應輸入的Callable 對象的集合的運行結果。
- 這裏提交的任務容器列表和返回的Future列表存在順序對應的關係。
ThreadPoolExecutor
execute(Runnable)方法
線程池是如何執行輸入的任務，這個整個線程池實現的核心邏輯，我們從這個方法開始學習。其代碼如下所示：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
可以發現，當提交一個新任務到線程池時，線程池的處理流程如下：
- 判斷線程池中工作的線程數是否小於核心線程數(corePoolSize)。如果是，則新建一個新的工作線程來執行任務(需要獲取全局鎖)。否則，進入下個流程。
- 判斷線程池的工作隊列(BlockingQeue)是否已滿。如果未滿，將新加的任務存儲在工作隊列中。否則，進入下個流程。
- 判斷線程池中工作的線程數是否小於最大線程數(maximumPoolSize)。如果小於，則新建一個工作線程來執行任務(需要獲取全局鎖)。
- 如果大於或者等於，則交給飽和策略處理這個任務。
新提交任務處理流程圖
以流程圖來說明的話，線程池處理一個新提交的任務的流程如下圖所示：
ThreadPoolExecutor執行示意圖
從上面的內容，我們可以發現線程池對於一個新任務有4種處理的可能，分別對應於上面處理流程的4個步驟。
ThreadPoolExecutor採取上述步驟的總體設計思路，是爲了在執行execute()方法時，儘可能地避免獲取全局鎖（那將會是一個嚴重的可伸縮瓶頸）。在ThreadPoolExecutor完成預熱之後（當前運行的線程數大於等於corePoolSize），幾乎所有的execute()方法調用都是執行步驟2，而步驟2不需要獲取全局鎖。
工作線程
從上面execute(Runnable)的代碼我們可以發現，線程池創建線程時，會將線程封裝成工作線程Worker，Worker在執行完任務後，還會循環獲取工作隊列裏的任務來執行。
ThreadPoolExecutor中線程執行任務的示意圖如下所示：
線程池中的線程執行任務分兩種情況：
- 在execute()方法中創建一個線程時，會讓這個線程執行當前任務。
- 這個線程執行完上圖中1的任務後，會反覆從BlockingQueue獲取任務來執行。
ThreadPoolExecutor的ctl變量
ctl 是一個 AtomicInteger 的類，保存的 int 變量的更新都是原子操作，保證線程安全。它的前面3位用來表示線程池狀態，後面29位用來表示工程線程數量。
ThreadPoolExecutor的狀態
線程池的狀態有5種：
-
Running：線程池處在Running的狀態時，能夠接收新任務，以及對已添加的任務進行處理。線程池的初始化狀態是RUNNING。換句話說，線程池被一旦被創建，就處於Running狀態，並且線程池中的任務數爲0。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); -
Shutdown: 線程池處在SHUTDOWN狀態時，不接收新任務，但能處理已添加(正在運行的以及在BlockingQueue)的任務。調用線程池的shutdown()接口時，線程池由RUNNING -> SHUTDOWN。
-
Stop: 線程池處在STOP狀態時，不接收新任務，不處理已添加的任務，並且會中斷正在運行的任務。 調用線程池的shutdownNow()接口時，線程池由(RUNNING or SHUTDOWN ) -> STOP。
-
Tidying: 當所有的任務已終止，ctl記錄的”任務數量”爲0，線程池會變爲Tidying狀態。當線程池變爲Tidying狀態時，會執行鉤子函數terminated()。terminated()在ThreadPoolExecutor類中是空的，若用戶想在線程池變爲Tidying時，進行相應的處理；可以通過重載terminated()函數來實現。
-
Terminated: 線程池徹底終止，就變成Terminated狀態。 線程池處在Tidying狀態時，執行完terminated()之後，就會由 Tidying -> Terminated。
線程池的使用
線程池的創建
我們可以通過ThreadPoolExecutor的構造函數來創建一個線程池。
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
- corePoolSize（線程池的核心線程數）:線程池要保持的線程數目，即使是他們是空閒也不會停止。 當提交一個任務到線程池時，線程池會創建一個線程來執行任務，即使其他空閒的基本線程能夠執行新任務也會創建線程，等到需要執行的任務數大於線程池基本大小時就不再創建。如果調用了線程池的prestartAllCoreThreads()方法，線程池會提前創建並啓動所有基本線程。
- maximumPoolSize（線程池的最大線程數）: 線程池允許創建的最大線程數。如果隊列滿了，並且已創建的線程數小於最大線程數，則線程池會再創建新的線程執行任務。值得注意的是，如果使用了無界的任務隊列這個參數就沒什麼效果。
- keepAliveTime（線程活動保持時間）: 當線程池中的線程數大於corePoolSize時，keepAliveTime爲多餘的空閒線程等待新任務的最長保持存活的時間。所以，如果任務很多，並且每個任務執行的時間比較短，可以調大時間，提高線程的利用率。
- unit(線程活動保持時間的單位) : 可選的單位有天（DAYS）、小時（HOURS）、分鐘（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS，千分之一毫秒）和納秒（NANOSECONDS，千分之一微秒）。
- runnableTaskQueue（任務隊列）：用於保存等待執行的任務的阻塞隊列。可以選擇以下幾個阻塞隊列。
- ArrayBlockingQueue：是一個基於數組結構的有界阻塞隊列，此隊列按FIFO（先進先出）原則對元素進行排序。
- LinkedBlockingQueue：一個基於鏈表結構的無界阻塞隊列，此隊列按FIFO排序元素，吞吐量通常要高於ArrayBlockingQueue。靜態工廠方法Executors.newFixedThreadPool()使用了這個隊列。
- SynchronousQueue：一個不存儲元素的阻塞隊列。每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處於阻塞狀態，吞吐量通常要高於Linked-BlockingQueue，靜態工廠方法Executors.newCachedThreadPool使用了這個隊列。
- PriorityBlockingQueue：一個具有優先級的無限阻塞隊列。
- ThreadFactory：用於設置創建線程的工廠，可以通過線程工廠給每個創建出來的線程設置更有意義的名字。
- RejectedExecutionHandler（飽和策略）：當ThreadPoolExecutor已經關閉或ThreadPoolExecutor已經飽和 時（達到了最大線程池大小且工作隊列已滿），execute()方法將要調用的Handler，那麼必須採取一種策略處理提交的新任務。這個策略默認情況下是AbortPolicy。Java線程池框架提供了以下4種策略：
- AbortPolicy：直接拋出異常
- CallerRunsPolicy：只用調用者所在線程來運行任務
- DiscardOldestPolicy：丟棄隊列裏最老的一個任務，並執行當前任務
- DiscardPolicy：不處理，丟棄掉
常用ThreadPoolExecutor
通過Executor框架的工具類Executors，可以創建以下3種類型的ThreadPoolExecutor。通過源碼可以發現這3種線程池的本質都是不同輸入參數配置的ThreadPoolExecutor。
FixedThreadPool
FixedThreadPool被稱爲可重用固定線程數的線程池。下面是FixedThreadPool的源代碼實現。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
注意到，
- FixedThreadPool的corePoolSize和maximumPoolSize都被設置爲創建時的同一個指定的參數nThreads。
- 任務阻塞隊列使用的是無界隊列new LinkedBlockingQueue()。
- keepAliveTime設置爲0。
- ThreadFactory和RejectedExecutionHandler皆使用的默認值。
FixedThreadPool的execute()方法的運行示意圖如下所示：
其運行說明：
- 如果當前運行的線程數少於corePoolSize，則創建新線程來執行任務。
- 在線程池完成預熱之後（當前運行的線程數等於corePoolSize），將任務加入LinkedBlockingQueue。
- 線程執行完1中的任務後，會在循環中反覆從LinkedBlockingQueue獲取任務來執行。
FixedThreadPool使用無界隊列LinkedBlockingQueue作爲線程池的工作隊列（隊列的容量爲Integer.MAX_VALUE）對線程池會帶來如下影響：
- 當線程池中的線程數達到corePoolSize後，新任務將在無界隊列中等待。由於無界隊列永遠不會滿，因此線程池中的線程數不會超過corePoolSize。
- 由於1，使用無界隊列時maximumPoolSize將是一個無效參數。
- 由於1和2，使用無界隊列時keepAliveTime將是一個無效參數。不會有超過corePoolSize的線程數目。
- 由於使用無界隊列。運行中的FixedThreadPool（未執行方法shutdown()或shutdownNow()）不會拒絕任務（不會調用RejectedExecutionHandler.rejectedExecution方法）。
SingleThreadExecutor
SingleThreadExecutor是使用單個worker線程的Executor。SingleThreadExecutor與FixedThreadPool類似，只是它的corePoolSize和maximumPoolSize被設置爲1。下面是SingleThreadExecutor的源代碼實現。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
CachedThreadPool
CachedThreadPool是一個會根據需要創建新線程的線程池。下面是創建CachedThread-Pool的源代碼。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
注意到：
- CachedThreadPool的corePoolSize被設置爲0，即corePool爲空；maximumPoolSize被設置爲 Integer.MAX_VALUE，即maximumPool是無界的。
- keepAliveTime設置爲60L，意味着CachedThreadPool中的空閒線程等待新任務的最長時間爲60秒，空閒線程超過60秒後將會被終止。
- CachedThreadPool使用沒有容量的SynchronousQueue作爲線程池的工作隊列，但CachedThreadPool的maximumPool是無界的。這意味着，如果主線程提交任務的速度高於maximumPool中線程處理任務的速度時，CachedThreadPool會不斷創建新線程。極端情況下，CachedThreadPool會因爲創建過多線程而耗盡CPU和內存資源。
CacheThreadPool的execute()方法的執行過程如下圖所示：
其執行過程的說明如下：
- 首先執行SynchronousQueue.offer（Runnable task）。如果當前maximumPool中有空閒線程正在執行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS），那麼主線程執行offer操作與空閒線程執行的poll操作配對成功，主線程把任務交給空閒線程執行；否則執行下面的步驟2。
- 當初始maximumPool爲空，或者maximumPool中當前沒有空閒線程時，將沒有線程執行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。這種情況下，CachedThreadPool將會創建一個新線程執行任務。
- 步驟2中新創建的線程將任務執行完後，會執行SynchronousQueue.poll（keepAliveTime，TimeUnit.NANOSECONDS）。這個poll操作會讓空閒線程最多在SynchronousQueue中等待60秒鐘。如果60秒鐘內主線程提交了一個新任務（主線程執行步驟1），那麼這個空閒線程將執行主線程提交的新任務；否則，這個空閒線程將終止。由於空閒60秒的空閒線程會被終止，因此長時間保持空閒的CachedThreadPool不會使用任何資源。
向線程池提交任務
可以使用兩個方法向線程池提交任務，分別爲execute()和submit()方法。
-
execute()方法用於提交不需要返回值的任務，所以無法判斷任務是否被線程池執行成功。一般execute()方法輸入的任務是一個Runnable類的實例。
-
submit()方法用於提交需要返回值的任務。線程池會返回一個future類型的對象，通過這個future對象可以判斷任務是否執行成功，並且可以通過future的get()方法來獲取返回值，get()方法會阻塞當前線程直到任務完成，而使用get（long timeout，TimeUnit unit）方法則會阻塞當前線程一段時間後立即返回，這時候有可能任務沒有執行完。
關閉線程池
可以通過調用線程池的shutdown或者shutdownNow方法來關閉線程池。它們的原理是遍歷線程池中的工作線程，然後逐個調用線程的interrupt方法來中斷線程，所以無法響應中斷的任務可能永遠無法終止。但是它們存在一定的區別。
- shutdown首先將線程池的狀態設置成SHUTDOWN。然後阻止新提交的任務，對於新提交的任務，如果測試到狀態不爲RUNNING，則拋出rejectedExecution 。對於已經提交(正在運行的以及在任務隊列中的)任務不會產生任何影響。同時會將那些閒置的線程(idleWorkers)進行中斷。
- shutdownNow首先將線程池的狀態設置成STOP。然後阻止新提交的任務，對於新提交的任務，如果測試到狀態不爲RUNNING，則拋出rejectedExecution 同時會中斷當前正在運行的線程。另外它還將BolckingQueue中的任務給移除，並將這些任務添加到列表中進行返回。
線程池的監控
可以通過線程池提供的參數進行監控，在監控線程池的時候可以使用以下屬性：
-
taskCount：線程池需要執行的任務數量。
-
completedTaskCount：線程池在運行過程中已完成的任務數量，小於或等於taskCount。
-
largestPoolSize：線程池裏曾經創建過的最大線程數量。通過這個數據可以知道線程池是 否曾經滿過。如該數值等於線程池的最大大小，則表示線程池曾經滿過。
-
getPoolSize：線程池的線程數量。如果線程池不銷燬的話，線程池裏的線程不會自動銷 毀，所以這個大小隻增不減。
-
getActiveCount：獲取活動的線程數。
另外，通過擴展線程池進行監控。可以通過繼承線程池來自定義線程池，重寫線程池的beforeExecute、afterExecute和terminated方法，也可以在任務執行前、執行後和線程池關閉前執行一些代碼來進行監控。例如，監控任務的平均執行時間、最大執行時間和最小執行時間等。這幾個方法在線程池裏是空方法。