【JDK源碼分析系列】ThreadPoolExecutor 源碼解析 -- 任務提交與運行
【1】線程池任務的提交
【1.1】AbstractExecutorService -- submit
submit 方法主要完成的任務
1. 把 Runnable 和 Callable 都轉化成 FutureTask；
2. 使用 execute 方法執行 FutureTask；
// submit 方法是使用線程池時提交任務的方法，支持 Runable 和 Callable 兩種任務的提交，
// 方法中 execute 方法是其子類 ThreadPoolExecutor 實現的，不管是哪種任務入參，
// execute 方法最終執行的任務都是 FutureTask
//
// 提交無返回值的 Runnable 任務
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
// ftask 其實是 FutureTask
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
// 提交有返回值的 Runnable 任務，
// task 是 Runnable 類型在 FutureTask 中進行向 Callable 的轉換
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;
}
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
// 提交 Callable 任務
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
【1.2】ThreadPoolExecutor -- execute
// 阻塞隊列的常見方法總結 :
// 1、offer()和add()的區別
// add()和offer()都是向隊列中添加一個元素
// 但是如果想在一個滿的隊列中加入一個新元素，調用 add() 方法就會拋出一個unchecked 異常，
// 而調用 offer() 方法會返回 false；
// 2、peek()和element()的區別
// peek()和element()都將在不移除的情況下返回隊頭，
// 但是peek()方法在隊列爲空時返回null，調用element()方法會拋出NoSuchElementException異常；
// 3、poll()和remove()的區別
// poll()和remove()都將移除並且返回隊頭，
// 但是在poll()在隊列爲空時返回null，而remove()會拋出NoSuchElementException異常；
// 4、take():取走BlockingQueue裏排在首位的對象,若BlockingQueue爲空,阻塞i進入等待狀態直到Blocking有新的對象被加入爲止
public void execute(Runnable command) {
// 確保 command 不爲 null
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);
// 發現可運行的線程數是 0，就初始化一個線程，這裏是個極限情況，入隊的時候，突然發現
// 線程都被回收了
else if (workerCountOf(recheck) == 0)
// Runnable是空的，不會影響新增線程，但是線程在 start 的時候不會運行
// Thread.run() 裏面有判斷
addWorker(null, false);
}
// 隊列滿了，開啓線程到 maxSize，如果失敗直接拒絕,
else if (!addWorker(command, false))
// 調用拒絕策略
reject(command);
}
【1.3】ThreadPoolExecutor -- addWorker
// 結合線程池的情況看是否可以添加新的 worker
// firstTask 不爲空可以直接執行，爲空執行不了，Thread.run()方法有判斷，Runnable爲空不執行
// core 爲 true 表示線程最大新增個數是 coresize，false 表示最大新增個數是 maxsize
// 返回 true 代表成功，false 失敗
// break retry 跳到retry處，且不再進入循環
// continue retry 跳到retry處，且再次進入循環
//
//addWorker 方法首先是執行了一堆校驗，然後使用 new Worker (firstTask) 新建了 Worker，最後使用 t.start () 執行 Worker；
//Worker 在初始化時的關鍵代碼：this.thread = getThreadFactory ().newThread (this)，
//Worker（this） 是作爲新建線程的構造器入參的，所以 t.start () 會執行到 Worker 的 run 方法上
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 校驗各種狀態
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// rs >= SHUTDOWN 說明線程池狀態不正常
/**
* rs!=Shutdown || fistTask！=null || workCount.isEmpty
* 如果當前的線程池的狀態>SHUTDOWN 那麼拒絕Worker的add 如果=SHUTDOWN
* 那麼此時不能新加入不爲null的Task，如果在WorkCount爲empty的時候不能加入任何類型的Worker，
* 如果不爲empty可以加入task爲null的Worker,增加消費的Worker
*/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
// 工作中的線程數大於等於容量，或者大於等於 coreSize or maxSize
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
// break 結束 retry 的 for 循環
break retry;
c = ctl.get(); // Re-read ctl
// 線程池狀態被更改
if (runStateOf(c) != rs)
// 跳轉到retry位置
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 巧妙的設計，Worker 本身是個 Runnable.
// 在初始化的過程中，會把 worker 丟給 thread 去初始化
w = new Worker(firstTask);
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());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 包含線程池中所有的工作線程
// private final HashSet<Worker> workers = new HashSet<Worker>();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//啓動線程
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
//worker 啓動失敗則將 woker 從隊列中移除並中斷該 worker
addWorkerFailed(w);
}
return workerStarted;
}
【1.4】ThreadPoolExecutor -- addWorkerFailed
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//將 worker 從隊列中移除
if (w != null)
workers.remove(w);
//減少 worker 的數量
decrementWorkerCount();
//嘗試終止 workder
tryTerminate();
} finally {
mainLock.unlock();
}
}
【2】線程池任務的運行
【2.1】ThreadPoolExecutor -- runWorker
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
//幫助gc回收
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 1：任務入隊列了，若沒有運行的線程，於是新增一個線程；
// 2：線程執行完任務執行，再次回到 while 循環
// 如果 task 爲空，會使用 getTask 方法阻塞從隊列中拿數據，如果拿不到數據，會阻塞住
while (task != null || (task = getTask()) != null) {
//鎖住worker
w.lock();
// 線程池stop中,但是線程沒有到達中斷狀態，幫助線程中斷
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//執行before鉤子函數
//由子類實現
beforeExecute(wt, task);
Throwable thrown = null;
try {
//同步執行任務
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
//執行after鉤子函數,如果這裏拋出異常，會覆蓋catch的異常
//所以這裏異常最好不要拋出來
//由子類實現
afterExecute(task, thrown);
}
} finally {
//任務執行完成，計算解鎖
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//做一些拋出異常的善後工作
processWorkerExit(w, completedAbruptly);
}
}
【2.2】ThreadPoolExecutor -- getTask
// 從阻塞隊列中拿任務
// 1. 使用隊列的 poll 或 take 方法從隊列中拿數據，根據隊列的特性，隊列中有任務可以返回，隊列中無任務會阻塞；
// 2. 方法中的第二個 if 判斷，說的是在滿足一定條件下 (條件看註釋)，會減少空閒的線程，減少的手段是使可用線程數減一，
// 並且直接 return，直接 return 後，該線程就執行結束了，JVM 會自動回收該線程
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//線程池關閉 && 隊列爲空，不需要在運行了，直接放回
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
//直接 return 後，該線程就執行結束了，JVM 會自動回收該線程
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
// true 運行的線程數大於 coreSize || 核心線程也可以被滅亡
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 隊列以 LinkedBlockingQueue 爲例，timedOut 爲 true 說明 poll 方法執行返回的是 null
// 說明在等待 keepAliveTime 時間後，隊列中仍然沒有數據
// 說明此線程已經空閒了 keepAliveTime 了
// 再加上 wc > 1 || workQueue.isEmpty() 的判斷
// 所以使用 compareAndDecrementWorkerCount 方法使線程池數量減少 1
// 並且直接 return，return 之後，此空閒的線程會自動被回收
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
//減少線程池中的線程數量並釋放空閒線程
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 從隊列中拿 worker
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
// 設置已超時，說明此時隊列沒有數據
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
【2.3】ThreadPoolExecutor -- processWorkerExit
//做拋出異常時的善後工作
//開始清理並且標記一個即將銷燬的Worker
//傳入參數
//Worker w：要執行退出的Worker對象
//boolean completedAbruptly：是否用戶異常退出，true爲異常退出
private void processWorkerExit(Worker w, boolean completedAbruptly) {
//添加任務時workerCount已經+1了，completedAbruptly=true表示消費的時候出異常了
//判斷是否是意外退出的，如果是意外退出的話，那麼就需要把WorkerCount--
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//加完鎖後，同步將completedTaskCount進行增加，表示總共完成的任務數，
//並且從WorkerSet中將對應的Worker移除
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
//調用tryTemiate，進行判斷當前的線程池是否處於SHUTDOWN狀態，判斷是否要終止線程
tryTerminate();
int c = ctl.get();
//判斷當前的線程池狀態，如果當前線程池狀態比STOP大的話，就不處理
if (runStateLessThan(c, STOP)) {
//判斷是否是意外退出，如果不是意外退出的話，那麼就會判斷最少要保留的核心線程數，
//如果allowCoreThreadTimeOut被設置爲true的話，那麼說明核心線程在設置的KeepAliveTime之後，也會被銷燬
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
//如果最少保留的Worker數爲0的話，那麼就會判斷當前的任務隊列是否爲空，
//如果任務隊列不爲空的話而且線程池沒有停止，那麼說明至少還需要1個線程繼續將任務完成
if (min == 0 && ! workQueue.isEmpty())
min = 1;
//判斷當前的Worker是否大於min，也就是說當前的Worker總數大於最少需要的Worker數的話，
//那麼就直接返回，因爲剩下的Worker會繼續從WorkQueue中獲取任務執行
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//如果當前運行的Worker數比當前所需要的Worker數少的話，那麼就會調用addWorker，
//添加新的Worker，也就是新開啓線程繼續處理任務
addWorker(null, false);
}
}
【2.4】ThreadPoolExecutor -- tryTerminate
//試圖終止
//在以下情況將線程池變爲TERMINATED終止狀態
//shutdown且正在運行的worker和workQueue隊列都empty
//stop且沒有正在運行的worker
//
//這個方法必須在任何可能導致線程池終止的情況下被調用，如：
//減少worker數量
//shutdown時從queue中移除任務
//這個方法不是私有的，所以允許子類ScheduledThreadPoolExecutor調用
final void tryTerminate() {
for (;;) {
int c = ctl.get();
//正在運行
if (isRunning(c) ||
//tidying terminated
runStateAtLeast(c, TIDYING) ||
//shutdown 且 隊列不爲空
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
//綜合上面3個條件，可以推斷出當線程池stop或者shutdown
//且任務隊列爲空，就可以去terminated了
return;
//worker的數量不爲零，說明還有任務在執行，所以先不要terminated線程池
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
//如果狀態是SHUTDOWN，workQueue也爲空了，正在運行的worker也沒有了，開始terminated
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//CAS：將線程池的ctl變成TIDYING(所有的任務被終止，workCount爲0，爲此狀態時將會調用terminated()方法)，
//期間ctl有變化就會失敗，會再次for循環
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
//終止線程, 由子類實現
terminated();
} finally {
//將線程池的ctl變成TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
//喚醒調用等待線程池終止的線程awaitTermination()
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
// 如果上面的CAS判斷false，再次循環
}
}
【2.5】ThreadPoolExecutor -- interruptIdleWorkers
//回收空餘線程
//onlyOne如果爲true，最多interrupt一個worker
//只有當終止流程已經開始，但線程池還有worker線程時,tryTerminate()方法會做調用onlyOne爲true的調用
//(終止流程已經開始指的是：shutdown狀態且workQueue爲空或者stop狀態)
//在這種情況下，最多有一個worker被中斷，爲了傳播shutdown信號，以免所有的線程都在等待
//爲保證線程池最終能終止，這個操作總是中斷一個空閒worker
//而shutdown()中斷所有空閒worker，來保證空閒線程及時退出
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//循環回收，onlyOne=false,說明要回收很多個
for (Worker w : workers) {
Thread t = w.thread;
//線程沒有被打斷，並且worker可以獲得鎖,那麼當前線程可以被打斷
if (!t.isInterrupted() && w.tryLock()) {
try {
//建議線程中斷
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
//退出循環
break;
}
} finally {
mainLock.unlock();
}
}
參考致謝
本博客爲博主的學習實踐總結，並參考了衆多博主的博文，在此表示感謝，博主若有不足之處，請批評指正。
【2】Java線程池ThreadPoolExecutor使用和分析(二) - execute()原理
【3】深入理解java線程池—ThreadPoolExecutor
【4】Java線程池---processWorkerExit方法解析