Java執行緒池架構原理和原始碼解析
其實你可以自己new一個ThreadPoolExecutor,來達到自己的引數可控的程度,例如,可以將LinkedBlockingQueue換成其它的(如:SynchronousQueue),只是可讀性會降低,這裡只是使用了一種設計模式。
現在來看看ThreadPoolExecutor的原始碼是怎麼樣的,也許剛開始看他的原始碼會很痛苦,因為不知道作者為什麼是這樣設計的,所以本文介紹構造方法中對那些屬性做了賦值:
原始碼段1:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
這裡你可以看到最終賦值的過程,可以先大概知道下引數的意思:
corePoolSize:核心執行的poolSize,也就是當超過這個範圍的時候,就需要將新的Thread放入到等待佇列中了;
maximumPoolSize:一般你用不到,當大於了這個值就會將Thread由一個丟棄處理機制來處理,但是當你發生:newFixedThreadPool的時候,corePoolSize和maximumPoolSize是一樣的,而corePoolSize是先執行的,所以他會先被放入等待佇列,而不會執行到下面的丟棄處理中,看了後面的程式碼你就知道了。
workQueue:等待佇列,當達到corePoolSize的時候,就向該等待佇列放入執行緒資訊(預設為一個LinkedBlockingQueue),執行中的佇列屬性為:workers,為一個HashSet;內部被包裝了一層,後面會看到這部分程式碼。
keepAliveTime:預設都是0,當執行緒沒有任務處理後,保持多長時間,cachedPoolSize是預設60s,不推薦使用。
threadFactory:是構造Thread的方法,你可以自己去包裝和傳遞,主要實現newThread方法即可;
handler:也就是引數maximumPoolSize達到後丟棄處理的方法,java提供了5種丟棄處理的方法,當然你也可以自己弄,主要是要實現介面:RejectedExecutionHandler中的方法:
public void rejectedExecution(Runnabler, ThreadPoolExecutor e)
java預設的是使用:AbortPolicy,他的作用是當出現這中情況的時候會丟擲一個異常;其餘的還包含:
1、CallerRunsPolicy:如果發現執行緒池還在執行,就直接執行這個執行緒
2、DiscardOldestPolicy:線上程池的等待佇列中,將頭取出一個拋棄,然後將當前執行緒放進去。
3、DiscardPolicy:什麼也不做
4、AbortPolicy:java預設,丟擲一個異常:RejectedExecutionException。
通常你得到執行緒池後,會呼叫其中的:submit方法或execute方法去操作;其實你會發現,submit方法最終會呼叫execute方法來進行操作,只是他提供了一個Future來託管返回值的處理而已,當你呼叫需要有返回值的資訊時,你用它來處理是比較好的;這個Future會包裝對Callable資訊,並定義一個Sync物件(),當你發生讀取返回值的操作的時候,會通過Sync物件進入鎖,直到有返回值的資料通知,具體細節先不要看太多,繼續向下:
來看看execute最為核心的方法吧:
原始碼段2:
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
}
}
這段程式碼看似簡單,其實有點難懂,很多人也是這裡沒看懂,沒事,我一個if一個if說:
首先第一個判定空操作就不用說了,下面判定的poolSize >= corePoolSize成立時候會進入if的區域,當然它不成立也有可能會進入,他會判定addIfUnderCorePoolSize是否返回false,如果返回false就會進去;
我們先來看下addIfUnderCorePoolSize方法的原始碼是什麼:
原始碼段3:
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}
可以發現,這段原始碼是如果發現小雨corePoolSize就會建立一個新的執行緒,並且呼叫執行緒的start()方法將執行緒執行起來:這個addThread()方法,我們先不考慮細節,因為我們還要先看到前面是怎麼進去的,這裡可以發信啊,只有沒有建立成功Thread才會返回false,也就是噹噹前的poolSize > corePoolSize的時候,或執行緒池已經不是在running狀態的時候才會出現;
注意:這裡在外部判定一次poolSize和corePoolSize只是初步判定,內部是加鎖後判定的,以得到更為準確的結果,而外部初步判定如果是大於了,就沒有必要進入這段有鎖的程式碼了。
此時我們知道了,當前執行緒數量大於corePoolSize的時候,就會進入【程式碼段2】的第一個if語句中,回到【原始碼段2】,繼續看if語句中的內容:
這裡標記為
原始碼段4:
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
第一個if,也就是噹噹前狀態為running的時候,就會去執行workQueue.offer(command),這個workQueue其實就是一個BlockingQueue,offer()操作就是在佇列的尾部寫入一個物件,此時寫入的物件為執行緒的物件而已;所以你可以認為只有執行緒池在RUNNING狀態,才會在佇列尾部插入資料,否則就執行else if,其實else if可以看出是要做一個是否大於MaximumPoolSize的判定,如果大於這個值,就會做reject的操作,關於reject的說明,我們在【原始碼段1】的解釋中已經非常明確的說明,這裡可以簡單看下原始碼,以應徵結果:
原始碼段5:
private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < maximumPoolSize && runState == RUNNING)
//在corePoolSize = maximumPoolSize下,該程式碼幾乎不可能執行
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}
void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
也就是如果執行緒池滿了,而且執行緒池呼叫了shutdown後,還在呼叫execute方法時,就會丟擲上面說明的異常:RejectedExecutionException
再回頭來看下【程式碼段4】中進入到等待佇列後的操作:
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
這段程式碼是要線上程池執行狀態不是RUNNING或poolSize == 0才會呼叫,他是幹啥呢?
他為什麼會不等於RUNNING呢?外面那一層不是判定了他== RUNNING了麼,其實有時間差就是了,如果是poolSize == 0也會執行這段程式碼,但是裡面的判定條件是如果不是RUNNING,就做reject操作,在第一個執行緒進去的時候,會將第一個執行緒直接啟動起來;很多人也是看這段程式碼很繞,因為不斷的迴圈判定類似的判定條件,你主要記住他們之間有時間差,要取最新的就好了。
此時貌似程式碼看完了?咦,此時有問題了:
1、 等待中的執行緒在後來是如何跑起來的呢?執行緒池是不是有類似Timer一樣的守護程序不斷掃描執行緒佇列和等待佇列?還是利用某種鎖機制,實現類似wait和notify實現的?
2、 執行緒池的執行佇列和等待佇列是如何管理的呢?這裡還沒看出影子呢!
NO,NO,NO!
Java在實現這部分的時候,使用了怪異的手段,神馬手段呢,還要再看一部分程式碼才曉得。
在前面【原始碼段3】中,我們看到了一個方法叫:addThread(),也許很少有人會想到關鍵在這裡,其實關鍵就是在這裡:
我們看看addThread()方法到底做了什麼。
原始碼段6:
private Thread addThread(Runnable firstTask) {
Worker w = new Worker(firstTask);
Thread t = threadFactory.newThread(w);
if (t != null) {
w.thread = t;
workers.add(w);
int nt = ++poolSize;
if (nt > largestPoolSize)
largestPoolSize = nt;
}
return t;
}
這裡建立了一個Work,其餘的操作,就是講poolSize疊加,然後將將其放入workers的執行佇列等操作;
我們主要關心Worker是幹什麼的,因為這個threadFactory對我們用途不大,只是做了Thread的命名處理;而Worker你會發現它的定義也是一個Runnable,外部開始在程式碼段中發現了呼叫哪個這個Worker的start()方法,也就是執行緒的啟動方法,其實也就是呼叫了Worker的run()方法,那麼我們重點要關心run方法是如何處理的
原始碼段7:
public void run() {
try {
Runnable task = firstTask;
firstTask = null;
while (task != null || (task = getTask()) != null) {
runTask(task);
task = null;
}
} finally {
workerDone(this);
}
}
FirstTask其實就是開始在建立work的時候,由外部傳入的Runnable物件,也就是你自己的Thread,你會發現它如果發現task為空,就會呼叫getTask()方法再判定,直到兩者為空,並且是一個while迴圈體。
那麼看看getTask()方法的實現為:
原始碼段8:
Runnable getTask() {
for (;;) {
try {
int state = runState;
if (state > SHUTDOWN)
return null;
Runnable r;
if (state == SHUTDOWN) // Help drain queue
r = workQueue.poll();
else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
else
r = workQueue.take();
if (r != null)
return r;
if (workerCanExit()) {
if (runState >= SHUTDOWN) // Wake up others
interruptIdleWorkers();
return null;
}
// Else retry
} catch (InterruptedException ie) {
// On interruption, re-check runState
}
}
}
你會發現它是從workQueue佇列中,也就是等待佇列中獲取一個元素出來並返回!
回過頭來根據程式碼段6理解下:
當前執行緒執行完後,在到workQueue中去獲取一個task出來,繼續執行,這樣就保證了執行緒池中有一定的執行緒一直在執行;此時若跳出了while迴圈,只有workQueue佇列為空才會出現或出現了類似於shutdown的操作,自然執行佇列會減少1,當再有新的執行緒進來的時候,就又開始向worker裡面放資料了,這樣以此類推,實現了執行緒池的功能。
更多大廠面試資料,有需要的話點贊+關注,私信我獲取全部文件!