摘要:從手寫線程池開始,逐步的分析這些代碼在Java的線程池中是如何實現的。
本文分享自華為雲社區《手寫線程池,對照學習ThreadPoolExecutor線程池實現原理!》,作者:小傅哥。
謝飛機,小記!,上次吃虧在線程上,這可能一次坑掉兩次嗎!
謝飛機:你問吧,我准備好了!!!
面試官:嗯,線程池狀態是如何設計存儲的?
謝飛機:這!下一個,下一個!
面試官:Worker 的實現類,為什么不使用 ReentrantLock 來實現呢,而是自己繼承AQS?
謝飛機:我…!
面試官:那你簡述下,execute 的執行過程吧!
謝飛機:再見!
一、線程池講解
1. 先看個例子
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10)); threadPoolExecutor.execute(() -> { System.out.println("Hi 線程池!"); }); threadPoolExecutor.shutdown(); // Executors.newFixedThreadPool(10); // Executors.newCachedThreadPool(); // Executors.newScheduledThreadPool(10); // Executors.newSingleThreadExecutor();
這是一段用於創建線程池的例子,相信你已經用了很多次了。
線程池的核心目的就是資源的利用,避免重復創建線程帶來的資源消耗。因此引入一個池化技術的思想,避免重復創建、銷毀帶來的性能開銷。
那么,接下來我們就通過實踐的方式分析下這個池子的構造,看看它是如何處理線程的。
2. 手寫一個線程池
2.1 實現流程
為了更好的理解和分析關於線程池的源碼,我們先來按照線程池的思想,手寫一個非常簡單的線程池。
其實很多時候一段功能代碼的核心主邏輯可能並沒有多復雜,但為了讓核心流程順利運行,就需要額外添加很多分支的輔助流程。就像我常說的,為了保護手才把擦屁屁紙弄那么大!
關於圖 21-1,這個手寫線程池的實現也非常簡單,只會體現出核心流程,包括:
- 有n個一直在運行的線程,相當於我們創建線程池時允許的線程池大小。
- 把線程提交給線程池運行。
- 如果運行線程池已滿,則把線程放入隊列中。
- 最后當有空閑時,則獲取隊列中線程進行運行。
2.2 實現代碼
public class ThreadPoolTrader implements Executor { private final AtomicInteger ctl = new AtomicInteger(0); private volatile int corePoolSize; private volatile int maximumPoolSize; private final BlockingQueue<Runnable> workQueue; public ThreadPoolTrader(int corePoolSize, int maximumPoolSize, BlockingQueue<Runnable> workQueue) { this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; } @Override public void execute(Runnable command) { int c = ctl.get(); if (c < corePoolSize) { if (!addWorker(command)) { reject(); } return; } if (!workQueue.offer(command)) { if (!addWorker(command)) { reject(); } } } private boolean addWorker(Runnable firstTask) { if (ctl.get() >= maximumPoolSize) return false; Worker worker = new Worker(firstTask); worker.thread.start(); ctl.incrementAndGet(); return true; } private final class Worker implements Runnable { final Thread thread; Runnable firstTask; public Worker(Runnable firstTask) { this.thread = new Thread(this); this.firstTask = firstTask; } @Override public void run() { Runnable task = firstTask; try { while (task != null || (task = getTask()) != null) { task.run(); if (ctl.get() > maximumPoolSize) { break; } task = null; } } finally { ctl.decrementAndGet(); } } private Runnable getTask() { for (; ; ) { try { System.out.println("workQueue.size:" + workQueue.size()); return workQueue.take(); } catch (InterruptedException e) { e.printStackTrace(); } } } } private void reject() { throw new RuntimeException("Error!ctl.count:" + ctl.get() + " workQueue.size:" + workQueue.size()); } public static void main(String[] args) { ThreadPoolTrader threadPoolTrader = new ThreadPoolTrader(2, 2, new ArrayBlockingQueue<Runnable>(10)); for (int i = 0; i < 10; i++) { int finalI = i; threadPoolTrader.execute(() -> { try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("任務編號:" + finalI); }); } } } // 測試結果 任務編號:1 任務編號:0 workQueue.size:8 workQueue.size:8 任務編號:3 workQueue.size:6 任務編號:2 workQueue.size:5 任務編號:5 workQueue.size:4 任務編號:4 workQueue.size:3 任務編號:7 workQueue.size:2 任務編號:6 workQueue.size:1 任務編號:8 任務編號:9 workQueue.size:0 workQueue.size:0
以上,關於線程池的實現還是非常簡單的,從測試結果上已經可以把最核心的池化思想體現出來了。主要功能邏輯包括:
- ctl,用於記錄線程池中線程數量。
- corePoolSize、maximumPoolSize,用於限制線程池容量。
- workQueue,線程池隊列,也就是那些還不能被及時運行的線程,會被裝入到這個隊列中。
- execute,用於提交線程,這個是通用的接口方法。在這個方法里主要實現的就是,當前提交的線程是加入到worker、隊列還是放棄。
- addWorker,主要是類 Worker 的具體操作,創建並執行線程。這里還包括了 getTask() 方法,也就是從隊列中不斷的獲取未被執行的線程。
好,那么以上呢,就是這個簡單線程池實現的具體體現。但如果深思熟慮就會發現這里需要很多完善,比如:線程池狀態呢,不可能一直奔跑呀!?、線程池的鎖呢,不會有並發問題嗎?、線程池拒絕后的策略呢?,這些問題都沒有在主流程解決,也正因為沒有這些流程,所以上面的代碼才更容易理解。
接下來,我們就開始分析線程池的源碼,與我們實現的簡單線程池參考對比,會更加容易理解 !
3. 線程池源碼分析
3.1 線程池類關系圖
以圍繞核心類 ThreadPoolExecutor 的實現展開的類之間實現和繼承關系,如圖 21-2 線程池類關系圖。
- 接口 Executor、ExecutorService,定義線程池的基本方法。尤其是 execute(Runnable command) 提交線程池方法。
- 抽象類 AbstractExecutorService,實現了基本通用的接口方法。
- ThreadPoolExecutor,是整個線程池最核心的工具類方法,所有的其他類和接口,為圍繞這個類來提供各自的功能。
- Worker,是任務類,也就是最終執行的線程的方法。
- RejectedExecutionHandler,是拒絕策略接口,有四個實現類;AbortPolicy(拋異常方式拒絕)、DiscardPolicy(直接丟棄)、DiscardOldestPolicy(丟棄存活時間最長的任務)、CallerRunsPolicy(誰提交誰執行)。
- Executors,是用於創建我們常用的不同策略的線程池,newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newSingleThreadExecutor。
3.2 高3位與低29位
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; private static final int TIDYING = 2 << COUNT_BITS; private static final int TERMINATED = 3 << COUNT_BITS;
在 ThreadPoolExecutor 線程池實現類中,使用 AtomicInteger 類型的 ctl 記錄線程池狀態和線程池數量。在一個類型上記錄多個值,它采用的分割數據區域,高3位記錄狀態,低29位存儲線程數量,默認 RUNNING 狀態,線程數為0個。
3.2 線程池狀態
圖 22-4 是線程池中的狀態流轉關系,包括如下狀態:
- RUNNING:運行狀態,接受新的任務並且處理隊列中的任務。
- SHUTDOWN:關閉狀態(調用了shutdown方法)。不接受新任務,,但是要處理隊列中的任務。
- STOP:停止狀態(調用了shutdownNow方法)。不接受新任務,也不處理隊列中的任務,並且要中斷正在處理的任務。
- TIDYING:所有的任務都已終止了,workerCount為0,線程池進入該狀態后會調 terminated() 方法進入TERMINATED 狀態。
- TERMINATED:終止狀態,terminated() 方法調用結束后的狀態。
3.3 提交線程(execute)
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); }
在閱讀這部分源碼的時候,可以參考我們自己實現的線程池。其實最終的目的都是一樣的,就是這段被提交的線程,啟動執行、加入隊列、決策策略,這三種方式。
- ctl.get(),取的是記錄線程狀態和線程個數的值,最終需要使用方法 workerCountOf(),來獲取當前線程數量。`workerCountOf 執行的是 c & CAPACITY 運算
- 根據當前線程池中線程數量,與核心線程數 corePoolSize 做對比,小於則進行添加線程到任務執行隊列。
- 如果說此時線程數已滿,那么則需要判斷線程池是否為運行狀態 isRunning(c)。如果是運行狀態則把不能被執行的線程放入線程隊列中。
- 放入線程隊列以后,還需要重新判斷線程是否運行以及移除操作,如果非運行且移除,則進行拒絕策略。否則判斷線程數量為0后添加新線程。
- 最后就是再次嘗試添加任務執行,此時方法 addWorker 的第二個入參是 false,最終會影響添加執行任務數量判斷。如果添加失敗則進行拒絕策略。
3.5 添加執行任務(addWorker)
private boolean addWorker(Runnable firstTask, boolean core)
第一部分、增加線程數量
retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; 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 { w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { int rs = runStateOf(ctl.get()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); 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) addWorkerFailed(w); } return workerStarted;
添加執行任務的流程可以分為兩塊看,上面代碼部分是用於記錄線程數量、下面代碼部分是在獨占鎖里創建執行線程並啟動。這部分代碼在不看鎖、CAS等操作,那么就和我們最開始手寫的線程池基本一樣了
- if (rs >= SHUTDOWN &&! (rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty())),判斷當前線程池狀態,是否為 SHUTDOWN、STOP、TIDYING、TERMINATED中的一個。並且當前狀態為 SHUTDOWN、且傳入的任務為 null,同時隊列不為空。那么就返回 false。
- compareAndIncrementWorkerCount,CAS 操作,增加線程數量,成功就會跳出標記的循環體。
- runStateOf(c) != rs,最后是線程池狀態判斷,決定是否循環。
- 在線程池數量記錄成功后,則需要進入加鎖環節,創建執行線程,並記錄狀態。在最后如果判斷沒有啟動成功,則需要執行 addWorkerFailed 方法,剔除到線程方法等操作。
3.6 執行線程(runWorker)
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; w.unlock(); // 允許中斷 boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) w.lock(); if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { beforeExecute(wt, task); Throwable thrown = null; try { task.run(); } finally { afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); } }
其實,有了手寫線程池的基礎,到這也就基本了解了,線程池在干嘛。到這最核心的點就是 task.run() 讓線程跑起來。額外再附帶一些其他流程如下;
- beforeExecute、afterExecute,線程執行的前后做一些統計信息。
- 另外這里的鎖操作是 Worker 繼承 AQS 自己實現的不可重入的獨占鎖。
- processWorkerExit,如果你感興趣,類似這樣的方法也可以深入了解下。在線程退出時候workers做到一些移除處理以及完成任務數等,也非常有意思
3.7 隊列獲取任務(getTask)
如果你已經開始閱讀源碼,可以在 runWorker 方法中,看到這樣一句循環代碼 while (task != null || (task = getTask()) != null)。這與我們手寫線程池中操作的方式是一樣的,核心目的就是從隊列中獲取線程方法。
private Runnable getTask() { 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); // Are workers subject to culling? boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) return null; continue; } try { Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
- getTask 方法從阻塞隊列中獲取等待被執行的任務,也就是一條條往出拿線程方法。
- if (rs >= SHUTDOWN ...,判斷線程是否關閉。
- wc = workerCountOf(c),wc > corePoolSize,如果工作線程數超過核心線程數量 corePoolSize 並且 workQueue 不為空,則增加工作線程。但如果超時未獲取到線程,則會把大於 corePoolSize 的線程銷毀掉。
- timed,是 allowCoreThreadTimeOut 得來的。最終 timed 為 true 時,則通過阻塞隊列的poll方法進行超時控制。
- 如果在 keepAliveTime 時間內沒有獲取到任務,則返回null。如果為false,則阻塞。
二、總結
- 這一章節並沒有完全把線程池的所有知識點都介紹完,否則一篇內容會有些臃腫。在這一章節我們從手寫線程池開始,逐步的分析這些代碼在Java的線程池中是如何實現的,涉及到的知識點也幾乎是我們以前介紹過的內容,包括:隊列、CAS、AQS、重入鎖、獨占鎖等內容。所以這些知識也基本是環環相扣的,最好有一些根基否則會有些不好理解。
- 除了本章介紹的,我們還沒有講到線程的銷毀過程、四種線程池方法的選擇和使用、以及在CPU密集型任務、IO 密集型任務時該怎么配置。另外在Spring中也有自己實現的線程池方法。這些知識點都非常貼近實際操作。