前言
在阿里巴巴Java開發手冊中有這麼兩段話，如下圖所示
可以看到提到的兩點，第一要求不能顯示的建立執行緒，也就是new Thread的這種形式，需要使用執行緒池對執行緒進行管理，第二不允許使用官方提供的四種執行緒池，而是需要通過自行建立的方式去建立執行緒池，更加理解執行緒池的允許規則
本文就基於JDK1.8的程式碼，對執行緒池原始碼進行解析，帶大家能夠更好的理解執行緒池的概念以及其執行規則，如有錯誤，請大家指出
一、ThreadPoolExecutor原始碼
1.建構函式
先從建構函式看起：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
複製程式碼- corePoolSize：核心執行緒的數量，預設不會被回收掉，但是如果設定了allowCoreTimeOut為true，那麼當核心執行緒閒置時，也會被回收。
- maximumPoolSize ：最大執行緒數量，執行緒池能容納的最大容量，上限被CAPACITY限制（2^29-1）（後續程式碼會看到）
- keepAliveTime：閒置執行緒被回收的時間限制，也就是閒置執行緒的存活時間
- unit ：keepAliveTime的單位
- workQueue ：用於存放任務的佇列
- threadFactory ：建立執行緒的工廠類
- handler 當任務執行失敗時，使用handler通知呼叫者，代表拒絕的策略
有的朋友可能還不是很清晰，舉個例子，一個公司，核心執行緒就是代表公司的內部核心員工，最大執行緒數量就是員工的最大數量，可能包含非內部員工，因為有一些試點或者簡單的專案，需要一些外協人員來做，也就是非核心執行緒，那麼當這些專案做完了或者失敗了，公司為了節約用人成本，就遣散非核心員工，也就是閒置執行緒的存活時間。假如核心員工每個人都很忙，但是需求又一波接一波，那就任務排期，也就是任務佇列，當任務佇列都滿了時候，還要來需求？對不起，不接受，直接拒絕，這也就是handler對應的拒絕策略了，可以例子不是很合適，但是主要幫助大家理解下大概的意思。
2.執行緒池狀態
開啟原始碼類，可以看到如下幾個變數
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;
// runState is stored in the high-order bits
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;
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
複製程式碼AtomicInteger是一個原子操作類，保證執行緒安全，採用低29位表示執行緒的最大數量，高3位表示5種執行緒池狀態，維護兩個引數，workCount和runState。workCount表示有效的執行緒數量，runState表示執行緒池的執行狀態。
- RUNNING：執行狀態，可以接受新任務並處理
- SHUTDOWN：關閉狀態，不會接受新的任務了，但是會處理佇列中還存在的任務
- STOP：停止狀態，不會接受新的任務，也不處理佇列任務，直接中斷
- TIDYING：表示所有任務已經終止了
- TERMINATED：表示
terminated()方法已經執行完成
引用一張圖片幫助大家理解5個狀態
3.執行流程
execute（）
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
//如果當前執行緒數量小於核心執行緒數量，執行addWorker建立新執行緒執行command任務
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果當前是執行狀態，將任務放入阻塞佇列，double-check執行緒池狀態
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//如果再次check，發現執行緒池狀態不是執行狀態了，移除剛才新增進來的任務，並且拒絕改任務
if (! isRunning(recheck) && remove(command))
reject(command);
//處於執行狀態，但是沒有執行緒，建立執行緒
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//往執行緒池中建立新的執行緒失敗，則reject任務
else if (!addWorker(command, false))
reject(command);
}
複製程式碼這裡大概總結下execute方法的執行流程，其實大家看原始碼方法註釋是一樣很好的學習方法
- 首先判斷當前執行緒數量是不是比核心執行緒數量少，如果是，直接建立核心執行緒執行任務，否則走第二步
- 如果當前執行緒數量等於核心執行緒數量了，那麼就任務排期，將任務放進任務佇列，放入成功後，再次check執行緒池狀態，這裡說明一下，在多執行緒的環境下，ctl.get()這個方法並不是一個原子操作，如果加入佇列後，執行緒池狀態改變了，不是RUNNING狀態，那麼這個任務將永遠不會被執行，所以需要再次check，如果不是RUNNING狀態，移除任務並拒絕任務，如果是RUNNING狀態並且當前沒有執行緒，則直接建立執行緒
- 走到這一步前提就是第二步中的新增佇列失敗了，也就是任務佇列滿了，那麼這個時候就考慮到建立非核心執行緒去執行任務，如果新增非核心執行緒也失敗，那就直接拒絕
這裡注意一點，當核心執行緒滿的時候，並不會去直接建立非核心執行緒去執行任務，而是先放進任務佇列，可以理解為需求任務首先是需要讓內部核心員工去完成的，任務佇列的優先順序是高於非核心員工的，addWorker()，這裡的傳進去的boolean值，就代表著建立核心執行緒或者非核心執行緒
reject()
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
複製程式碼拒絕任務很簡單，reject方法會呼叫handler的rejectedExecution(command,this)方法，handler是RejectedExecutionHandler介面，預設實現是AbortPolicy，下面是AbortPolicy的實現：
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
複製程式碼可以看到預設策略是直接丟擲異常的，這只是預設使用的策略，可以通過實現介面實現自己的邏輯。
addWorker()
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 這裡return false的情況有以下幾種
//1.當前狀態是stop及以上 2.當前是SHUTDOWN狀態，但是firstTask不為空
//3.當前是SHUTDOWN狀態，但是佇列中為空
//從第一節我們知道，SHUTDOWN狀態是不執行進來的任務的，但是會繼續執行佇列中的任務
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;
}
複製程式碼這裡就主要流程分析下
- 2層迴圈，外部迴圈查詢執行緒池狀態，如果當前是stop及之上的狀態，直接return，如果是SHUTDOWN狀態，並且firstTask不為空或者佇列中是空的，直接return
- 內部迴圈查詢執行緒數量，通過傳遞進來的boolean值，分別和核心執行緒以及最大執行緒數量進行對比，如果成立，worker數量+1，並且跳出迴圈。
- 跳出迴圈就是實際執行任務了，Worker就將工作執行緒和任務封裝到了自己內部，我們可以將Worker看成就是一個工作執行緒，至於Worker是如何執行任務和從阻塞佇列中取任務
Worker()
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
......
}
複製程式碼可以看到，Worker內部維護，一個執行緒變數以及任務變數，啟動一個 Worker物件中包含的執行緒 thread, 就相當於要執行 runWorker()方法, 並將該 Worker物件作為該方法的引數.
runWorker()
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//task不為空，執行當前任務，任務執行完後將task置位空，getTask方法接著不斷從佇列中取任務
while (task != null || (task = getTask()) != null) {
w.lock();
//再次check執行緒池狀態，如果是stop狀態，直接interrupt()中斷任務
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();
} 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;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
複製程式碼通過while迴圈不斷的呼叫getTask方法，獲取任務task並進行執行，如果任務都執行完，跳出迴圈，執行緒結束並減少當前執行緒數量。
getTask()
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;
}
}
}
複製程式碼這裡主要有兩個判斷需要說明下：
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize
allowCoreThreadTimeOut ：這個第一節有說過，如果核心執行緒設定了該屬性，也是需要進行回收的，wc > corePoolSize：當前執行緒是非核心執行緒也是需要回收的，滿足任何一個條件，timed 置位true
timed ?workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take()
如果上述的timed標誌位為true，呼叫poll方法獲取任務，同時設定超時時間，如果沒有任務，則超時返回null，跳出runWorker的迴圈，執行緒結束被回收，如果為false，呼叫take方法，此時如果沒有任務，不會返回null，而是會進入阻塞狀態，等待任務，不會被回收
二、總結
執行緒池中的細節比較多，大致做一下總結歸納
- 執行緒池的構造引數決定了執行緒池的執行策略，需要理解每個引數的含義，因為每個引數的不同很大程度上決定了這個執行緒池的執行規則，這也是為什麼阿里巴巴開發手冊中提到通過自行建立的方式去建立執行緒池，而不是使用官方提供的4種執行緒池
- 執行緒池涉及多執行緒問題，狀態改變比較頻繁，在進行任務執行時，需要多次check執行緒池的狀態，保證任務被執行的準確性
- 任務佇列的優先順序高於非核心執行緒，核心執行緒滿的時候，會先把任務放進任務佇列，其次開啟非核心執行緒進行執行
- 核心執行緒和非核心執行緒本質上並沒有什麼區別，在核心執行緒設定allowCoreThreadTimeOut 屬性為true時，最終也會因為超時而被銷燬
- 執行緒池總覽就是通過兩個變數來整體控制整個流程，執行緒池的狀態，執行緒池中執行緒數量，涉及的方法不是很多，但是迴圈比較多，需要理解每個迴圈的跳出條件以及對應的狀態。
大概分析就是這麼多，希望有能夠幫助到一些朋友更好的理解執行緒池的工作原理以及在使用中能夠更好的使用，如有疑問或者錯誤，歡迎一起討論