該篇算是對Java線程池解析（上）的一個補充，從源碼的角度分析了下ThreadPoolExecutor。建議先看下Java線程池解析（上）在看該篇，這樣會順暢不少。如果文中有任何疑問歡迎留言討論。覺得好的話歡迎轉發評論。
我們先看下類圖結構：
一.
線程池成員變量ctl是Integer原子變量類型，使用一個變量同時記錄線程池狀態和線程池中工作線程（worker線程）個數，java中int變量是32位，如下面代碼所示，其中高三位表示線程池狀態，後邊的29位用來記錄worker線程數
//用來標記線程池的狀態（高三位）；線程個數（後29位）
//默認是RUNNING狀態，線程個數0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
//線程最大 個數
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
線程池的主要狀態如下：
//接收新任務並且處理阻塞隊列裏的任務
private static final int RUNNING = -1 << COUNT_BITS;
//拒絕新任務但是處理阻塞隊列裏的任務
private static final int SHUTDOWN = 0 << COUNT_BITS;
//拒絕新任務並且拋棄阻塞隊列裏的任務，同時中斷正在處理的任務
private static final int STOP = 1 << COUNT_BITS;
//所有的任務都執行完（包括阻塞隊列裏的任務），當前線程池活動線程爲0，將要調用terminated方法
private static final int TIDYING = 2 << COUNT_BITS;
//線程的終止狀態，terminated方法執行完的狀態
private static final int TERMINATED = 3 << COUNT_BITS;
//用來記錄當前線程池工作的線程
private final HashSet<Worker> workers = new HashSet<Worker>();
這裏需要說明的是 terminated方法爲 線程池結束後調用的方法，鉤子方法，自己去重寫
獲取線程池狀態的函數有：
// 獲取高三位 線程狀態
private static int runStateOf(int c) { return c & ~CAPACITY; }
//獲取低29位線程個數值
private static int workerCountOf(int c) { return c & CAPACITY; }
//
private static int ctlOf(int rs, int wc) { return rs | wc; }
從類圖中我們知道ThreadPoolExecutor有一個內部類worker，該類繼承自AbstractQueuedSynchronizer和Runnable，該類是具體承載任務的線程對象，繼承aqs主要是實現了一個簡單的不可重入獨佔鎖，我們先看下源碼：
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** 要執行的任務（ThreadPoolExecutor.execute提交的任務），可能爲空*/
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
// 使用ThreadFactory構造Thread，這個構造的Thread內部的Runnable就是本身，也就是Worker。
//所以得到Worker的thread並start的時候，會執行Worker的run方法，也就是執行ThreadPoolExecutor的runWorker方法
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** 啓動一個線程 */
public void run() {
/** 這裏調用的其實是 ThreadPoolExecutor.runWorker 方法 */
runWorker(this);
}
protected boolean isHeldExclusively() { return getState() != 0; }
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
- 這裏需要說明下：worker實現獨佔鎖 主要是爲了標識worker線程是否爲空閒線程，如果這個線程正在處理具體的任務 那麼就不是空閒線程
二.提交任務到線程池的源碼解析
提交任務到線程池，ThreadPoolExecutor提供了四種實現方式，源碼如下：
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;
}
上面三種是有返回值的，我看可以看到 最後都是調用的execute方法，來看一下第四種提交任務的execute方法
//提交任務到線程池的邏輯
public void execute(Runnable command) {
//如果任務爲null，則拋出空指針
if (command == null)
throw new NullPointerException();
//獲取當前線程狀態 + 線程個數 組合值
int c = ctl.get();
//當前線程個數 是否小於corePoolSize ，小於則開啓新線程執行任務
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果當前線程池狀態爲running 添加任務到阻塞隊列
if (isRunning(c) && workQueue.offer(command)) {
//二次檢查線程池狀態
int recheck = ctl.get();
//如果線程池狀態不爲running 則移除剛添加到阻塞隊列裏的任務，並執行拒絕策略
if (! isRunning(recheck) && remove(command))
reject(command);
//如果當前線程池線程爲空 則添加一個線程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//添加任務到任務隊列失敗，嘗試創建新線程（這裏 線程數 < maximumPoolSize纔會創建，否則創建失敗），失敗執行拒絕策略
else if (!addWorker(command, false))
//實現 RejectedExecutionHandler接口（可以自己重寫）
reject(command);
}
提交任務到線程池大概分爲三步：
- 如果當前正在執行任務的Worker線程數量比corePoolSize(基本大小)要小。直接創建一個新的Worker線程執行任務，會調用addWorker方法，嘗試創建一個worker線程
- 如果當前正在執行任務的 Worker線程數量 >= corePoolSize(基本大小) 且 線程池的運行狀態爲RUNNING，將任務放到阻塞隊列裏 ，否則執行第3步。丟到阻塞隊列之後，還需要再做一次驗證(丟到阻塞隊列之後可能另外一個線程關閉了線程池或者剛剛加入到隊列的線程死了)。如果這個時候線程池不在RUNNING狀態，把剛剛丟入隊列的任務remove掉，調用reject方法，否則查看Worker數量，如果Worker數量爲0，起一個新的Worker去阻塞隊列裏拿任務執行
- 添加任務到阻塞隊列失敗，嘗試創建新線程（這裏 線程數 < maximumPoolSize纔會創建，否則創建失敗），失敗執行拒絕策略
我們看下addWorker方法：
// 兩個參數，firstTask表示需要跑的任務。boolean類型的core參數爲true的話表示使用線程池的基本大小，爲false使用線程池最大大小
// 返回值是boolean類型，true表示新任務被接收了，並且執行了。否則是false
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
//獲取當前線程狀態 + 線程個數 組合值
int c = ctl.get();
//獲取當前線程狀態
int rs = runStateOf(c);
// 官方注： 僅在必要時檢查隊列是否爲空
// 這個判斷轉換成 rs >= SHUTDOWN && (rs != SHUTDOWN || firstTask != null || workQueue.isEmpty)。
// 概括爲3個條件：
// 1. 線程池不在RUNNING狀態並且狀態是STOP、TIDYING或TERMINATED中的任意一種狀態
// 2. 線程池不在RUNNING狀態，線程池接受了新的任務
// 3. 線程池不在RUNNING狀態，阻塞隊列爲空。 滿足這3個條件中的任意一個的話，拒絕執行任務
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
// 線程池線程個數
int wc = workerCountOf(c);
// 如果線程池線程數量超過線程池最大容量
// 或者線程數量超過了基本大小(core參數爲true，core參數爲false的話判斷超過最大大小)
// 超過的話 直接返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 沒有超過各種大小的話，cas操作線程池線程數量+1，cas成功的話跳出循環
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
// 如果狀態改變了，重新循環操作
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 任務是否成功啓動標識
boolean workerStarted = false;
// 任務是否添加成功標識
boolean workerAdded = false;
Worker w = null;
try {
//構建一個 worker 對象，創建一個工作線程，Worker實現了Runnable
//Worker.firstTask 暫存了 firstTask任務；
w = new Worker(firstTask);
//new Worker 時使用ThreadFactory構造了一個Thread
final Thread t = w.thread;
if (t != null) {
//防止併發
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
//獲取當前線程狀態
int rs = runStateOf(ctl.get());
//當前線程狀態爲RUNNING 或者 爲 SHUTDOWN 且 firstTask ==null
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//把通過new Worker創建的工作線程 放到set中存起來
workers.add(w);
int s = workers.size();
//largestPoolSize用來記錄活躍線程曾經最大的值
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
//任務添加成功，啓動剛纔創建好的工作線程
//t.start 啓動worker線程
if (workerAdded) {
t.start();// 注1
workerStarted = true;
}
}
} finally {
//任務啓動失敗
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
這裏主要是通過addWorker方法 創建一個worker線程，並維護進workers集合然後啓動該worker線程，
在上文中介紹ThreadPoolExecutor.Worker 類的時候我們知道Worker 繼承自Runnable 接口，所以注1中這裏是啓動worker線程我們在看下Worker.run 方法：
/** 啓動一個線程 */
public void run() {
/** 這裏調用的其實是 ThreadPoolExecutor.runWorker 方法 */
runWorker(this);
}
這裏是委託給runWorker方法，我們看下源碼：
// worker線程處理 提交的任務
final void runWorker(Worker w) {
//獲取當前線程
Thread wt = Thread.currentThread();
//要執行的 Runnable任務，可能爲空
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//執行當前任務或者 執行阻塞隊列中的任務(如果阻塞隊列爲空 將當前線程掛起阻塞隊列上（需要符合條件，具體見getTask）)
while (task != null || (task = getTask()) != null) { //注2
// 如果拿到了任務，給自己上鎖，表示當前Worker已經要開始執行任務了，已經不是閒置Worker（線程池關閉的時候需要用到該狀態）
w.lock();//注3
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
// 在執行任務之前先做一些處理。
// 1. 如果線程池已經處於STOP,TIDYING,TERMINATED狀態並且當前線程沒有被中斷，中斷線程
//2. 如果線程池還處於RUNNING或SHUTDOWN狀態，並且當前線程已經被中斷了，重新檢查一下線程池狀態，如果處於STOP狀態並且沒有被中斷，那麼中斷線程
if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//任務執行前 做點什麼事~；空方法，可以自己去重寫
beforeExecute(wt, task);
Throwable thrown = null;
try {
//真正的去執任務，這裏是調用run方法 而不是start方法
task.run();// 注：4
//任務執行發生的異常全部拋出，不在runWorker中處理
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
//任務執行後 做點什麼事~；空方法，可以自己去重寫
afterExecute(task, thrown);
}
} finally {
task = null;
// 記錄當前worker線程執行任務的個數
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 回收worker線程
processWorkerExit(w, completedAbruptly);
}
}
runWorker方法的作用主要是用來處理線程池提交的任務（包括阻塞隊列）。見注2
如果阻塞隊列裏的任務也處理空就把當前線程掛起在阻塞隊列上（當且線程池處於RUNNING狀態 且 worker線程數小於corePoolSize），直到被中斷或者獲取到任務
這裏還需要注意的是如果worker線程開始處理任務以後將當前worker線程置爲非閒置狀態（給自己加鎖）。在回收worker線程時需要判斷當前worker線程是否正在處理任務。注 3
getTask用來獲取阻塞隊列的任務並我們看一下getTask方法是如何獲得任務的：
private Runnable getTask() {
// 用來標識阻塞隊列poll() 超時的情況
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
// 當前線程池線程數
int wc = workerCountOf(c);
// 標記從阻塞隊列中獲取任務時是否設置超時時間
//true: 說明這個worker可能需要回收(allowCoreThreadTimeOut設置爲true 或者 當前線程數 > 線程池核心線程數)
//false: 這個worker會一直存在，並且阻塞當前線程等待阻塞隊列中有數據
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//worker線程大於maximumPoolSize 或者 在keepAliveTime時間內阻塞隊列爲空
if ((wc > maximumPoolSize || (timed && timedOut))
// 線程池的線程數 大於1或者worker阻塞隊列爲空（在阻塞隊列不爲空時，需要保證至少有一個worker）
&& (wc > 1 || workQueue.isEmpty())) {
// worker線程數量減一，返回null，之後會進行Worker回收工作
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// timed == true時，使用poll方法，worker線程keepAliveTime這麼多時間沒有獲取到阻塞隊列裏的任務 返回r == null
//否則使用take方法一直阻塞等待阻塞隊列新進數據
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
//用來標記超時後還沒獲取到阻塞隊列任務的情況
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
說明下getTask方法，獲取阻塞隊列中的任務， 如果阻塞隊列爲空將當前worker線程掛起，直到阻塞隊列有任務了
如果getTask方法返回null 則對當前worker線程回收，返回null 的情況有：
- 當 worker線程數 大於corePoolSize時 且 超過阻塞時間超過keepAliveTime沒有獲取到任務時，喚醒當前worker線程,並返回null 釋放掉當前線程資源
- 線程池處於STOP狀態
- 線程池處於SHUTDOWN狀態並且阻塞隊列爲空
- Worker個數 大於 maximumPoolSize(如果maximumPoolSize <= 1，還需要判斷阻塞隊列是否爲空)
當getTask線程返回null後 ，runWorker方法將會調用processWorkerExit方法回收worker線程，代碼如下：
private void processWorkerExit(Worker w, boolean completedAbruptly) {
//如果當前worker線程執行的任務發生了異常，需要減少線程池線程數量（workCount--）
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 銷燬當前worker線程時， 記錄當前worker線程處理任務的總數
completedTaskCount += w.completedTasks;
// 從workers集合中移除該worker
workers.remove(w);
} finally {
mainLock.unlock();
}
// 嘗試結束線程池
tryTerminate();
int c = ctl.get();
// 如果線程池還處於RUNNING或者SHUTDOWN狀態
if (runStateLessThan(c, STOP)) {
//worker線程是正常回收
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
//阻塞隊列不爲空的情況下 worker線程最少保留一個
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//當前worker線程執行的任務發生了異常時,新建一個worker線程替換因異常結束的線程
addWorker(null, false);
}
}
說明：
processWorkerExit第一個參數爲要回收的worker線程，第二個參數completedAbruptly爲true 說明worker線程是因爲執行的任務發生了異常而結束的，那麼就嘗試創建一個新的worker線程
正常情況下回收線程時每次都會調用下tryTerminate()方法嘗試結束當前線程池，代碼如下：
//嘗試結束 當前線程池，在worker線程被回收時都會嘗試結束線程池
final void tryTerminate() {
for (;;) {
int c = ctl.get();
// 滿足3個條件中的任意一個，不終止線程池
// 1. 線程池還在運行，不能終止
// 2. 線程池處於TIDYING或TERMINATED狀態，說明已經在關閉了，不允許繼續處理
// 3. 線程池處於SHUTDOWN狀態並且阻塞隊列不爲空，這時候還需要處理阻塞隊列的任務，不能終止線程池
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
// 走到這一步說明線程池已經不在運行，阻塞隊列已經沒有任務，但是還要回收正在工作的Worker
if (workerCountOf(c) != 0) { // Eligible to terminate
// 中斷閒置Worker，直到回收全部的Worker。
//這裏僅中斷一個，中斷之後結束interruptIdleWorkers方法，中斷了Worker之後，Worker會回收，然後還是會調用tryTerminate方法，如果還有閒置線程，那麼繼續中斷
interruptIdleWorkers(ONLY_ONE);//ONLY_ONE == true
return;
}
// 到這裏說明worker線程已經全部回收了，並且線程池已經不在運行，阻塞隊列已經沒有任務。可以準備結束線程池了
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// cas操作，將線程池狀態改成TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
//線程池退出前 做點什麼事~；空方法，可以自己去重寫
terminated();
} finally {
// terminated方法調用完畢之後，狀態變爲TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
//中斷閒置線程
//onlyOne爲true：只中斷一個閒置worker線程（該線程被回收的時候還會調用tryTerminate，如果有閒置線程還是會被回收的，所以該行爲會傳播）
//onlyOne爲false: 中斷所有閒置線程
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
到這裏 整個線程池的任務提交過程就講完了，下邊看下線程池關閉的過程
三.線程池關閉
1.shutdown()
線程池不在接收新任務，但是還是會處理阻塞隊列中的任務
這裏只會中斷閒置線程（那些掛起在阻塞隊列上的線程）
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 檢查關閉線程池的權限
checkShutdownAccess();
// 把線程池狀態更新到SHUTDOWN
advanceRunState(SHUTDOWN);
// 中斷閒置的Worker
interruptIdleWorkers(false);
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
//嘗試結束線程池，上文中有講到
tryTerminate();
}
interruptIdleWorkers源碼在上文中已經解釋了 這裏就不多說了
2.shutdownNow
拋棄阻塞隊列中的任務，不在接收新任務，並中斷所有worker線程
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 把線程池狀態更新到STOP
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
//中斷所有worker線程
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}