本文你將獲得以下信息：
- 線程池源碼解讀
- 線程池執行流程分析
- 帶返回值的線程池實現
- 延遲線程池實現
爲了方便讀者理解，本文會由淺入深，先從線程池的使用開始再延伸到源碼解讀和源碼分析等高級內容，讀者可根據自己的情況自主選擇閱讀順序和需要了解的章節。
一、線程池優點
線程池能夠更加充分的利用CPU、內存、網絡、IO等系統資源，線程池的主要作用如下：
- 利用線程池可以複用線程，控制最大併發數；
- 實現任務緩存策略和拒絕機制；
- 實現延遲執行
阿里巴巴Java開發手冊強制規定：線程資源必須通過線程池提供，如下圖：
二、線程池使用
本節會介紹7種線程池的創建與使用，線程池的狀態介紹，ThreadPoolExecutor參數介紹等。
2.1 線程池創建
線程池可以使用Executors和ThreadPoolExecutor，其中使用Executors有六種創建線程池的方法，如下圖：
// 使用Executors方式創建
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
ExecutorService workStealingPool = Executors.newWorkStealingPool();
// 原始創建方式
ThreadPoolExecutor tp = new ThreadPoolExecutor(10, 10, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());2.1.1 線程池解讀
- newSingleThreadExecutor()，它的特點在於工作線程數目被限制爲 1，操作一個無界的工作隊列，所以它保證了所有任務的都是被順序執行，最多會有一個任務處於活動狀態，並且不允許使用者改動線程池實例，因此可以避免其改變線程數目。
- newCachedThreadPool()，它是一種用來處理大量短時間工作任務的線程池，具有幾個鮮明特點：它會試圖緩存線程並重用，當無緩存線程可用時，就會創建新的工作線程；如果線程閒置的時間超過 60 秒，則被終止並移出緩存；長時間閒置時，這種線程池，不會消耗什麼資源。其內部使用 SynchronousQueue 作爲工作隊列。
- newFixedThreadPool(int nThreads)，重用指定數目（nThreads）的線程，其背後使用的是無界的工作隊列，任何時候最多有 nThreads 個工作線程是活動的。這意味着，如果任務數量超過了活動隊列數目，將在工作隊列中等待空閒線程出現；如果有工作線程退出，將會有新的工作線程被創建，以補足指定的數目 nThreads。
- newSingleThreadScheduledExecutor() 創建單線程池，返回 ScheduledExecutorService，可以進行定時或週期性的工作調度。
- newScheduledThreadPool(int corePoolSize)和newSingleThreadScheduledExecutor()類似，創建的是個 ScheduledExecutorService，可以進行定時或週期性的工作調度，區別在於單一工作線程還是多個工作線程。
- newWorkStealingPool(int parallelism)，這是一個經常被人忽略的線程池，Java 8 才加入這個創建方法，其內部會構建ForkJoinPool，利用Work-Stealing算法，並行地處理任務，不保證處理順序。
- ThreadPoolExecutor是最原始的線程池創建，上面1-3創建方式都是對ThreadPoolExecutor的封裝。
總結： 其中newSingleThreadExecutor、newCachedThreadPool、newFixedThreadPool是對ThreadPoolExecutor的封裝實現，newSingleThreadScheduledExecutor、newScheduledThreadPool則爲ThreadPoolExecutor子類ScheduledThreadPoolExecutor的封裝，用於執行延遲任務，newWorkStealingPool則爲Java 8新加的方法。
2.1.2 單線程池的意義
從以上代碼可以看出newSingleThreadExecutor和newSingleThreadScheduledExecutor創建的都是單線程池，那麼單線程池的意義是什麼呢？
雖然是單線程池，但提供了工作隊列，生命週期管理，工作線程維護等功能。
2.2 ThreadPoolExecutor解讀
ThreadPoolExecutor作爲線程池的核心方法，我們來看一下ThreadPoolExecutor內部實現，以及封裝類是怎麼調用ThreadPoolExecutor的。
先從構造函數說起，構造函數源碼如下：
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}參數說明：
- corePoolSize：所謂的核心線程數，可以大致理解爲長期駐留的線程數目（除非設置了 allowCoreThreadTimeOut）。對於不同的線程池，這個值可能會有很大區別，比如 newFixedThreadPool 會將其設置爲 nThreads，而對於 newCachedThreadPool 則是爲 0。
- maximumPoolSize：顧名思義，就是線程不夠時能夠創建的最大線程數。同樣進行對比，對於 newFixedThreadPool，當然就是 nThreads，因爲其要求是固定大小，而 newCachedThreadPool 則是 Integer.MAX_VALUE。
- keepAliveTime：空閒線程的保活時間，如果線程的空閒時間超過這個值，那麼將會被關閉。注意此值生效條件必須滿足：空閒時間超過這個值，並且線程池中的線程數少於等於核心線程數corePoolSize。當然核心線程默認是不會關閉的，除非設置了allowCoreThreadTimeOut(true)那麼核心線程也可以被回收。
- TimeUnit：時間單位。
- BlockingQueue：任務丟列，用於存儲線程池的待執行任務的。
- threadFactory：用於生成線程，一般我們可以用默認的就可以了。
- handler：當線程池已經滿了，但是又有新的任務提交的時候，該採取什麼策略由這個來指定。有幾種方式可供選擇，像拋出異常、直接拒絕然後返回等，也可以自己實現相應的接口實現自己的邏輯。
來看一下線程池封裝類對於ThreadPoolExecutor的調用：
newSingleThreadExecutor對ThreadPoolExecutor的封裝源碼如下：
public static ExecutorService newSingleThreadExecutor() {
return new Executors.FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}newCachedThreadPool對ThreadPoolExecutor的封裝源碼如下：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}newFixedThreadPool對ThreadPoolExecutor的封裝源碼如下：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}ScheduledExecutorService對ThreadPoolExecutor的封裝源碼如下：
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
}newSingleThreadScheduledExecutor使用的是ThreadPoolExecutor的子類ScheduledThreadPoolExecutor，如下圖所示：
newScheduledThreadPool對ThreadPoolExecutor的封裝源碼如下：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}newScheduledThreadPool使用的也是ThreadPoolExecutor的子類ScheduledThreadPoolExecutor。
2.3 線程池狀態
查看ThreadPoolExecutor源碼可知線程的狀態如下：
線程狀態解讀（以下內容來源於：https://javadoop.com/post/jav...）：
- RUNNING：這個沒什麼好說的，這是最正常的狀態：接受新的任務，處理等待隊列中的任務；
- SHUTDOWN：不接受新的任務提交，但是會繼續處理等待隊列中的任務；
- STOP：不接受新的任務提交，不再處理等待隊列中的任務，中斷正在執行任務的線程；
- TIDYING：所有的任務都銷燬了，workCount 爲 0。線程池的狀態在轉換爲 TIDYING 狀態時，會執行鉤子方法 terminated()；
- TERMINATED：terminated() 方法結束後，線程池的狀態就會變成這個；
RUNNING 定義爲 -1，SHUTDOWN 定義爲 0，其他的都比 0 大，所以等於 0 的時候不能提交任務，大於 0 的話，連正在執行的任務也需要中斷。
看了這幾種狀態的介紹，讀者大體也可以猜到十之八九的狀態轉換了，各個狀態的轉換過程有以下幾種：
- RUNNING -> SHUTDOWN：當調用了 shutdown() 後，會發生這個狀態轉換，這也是最重要的；
- (RUNNING or SHUTDOWN) -> STOP：當調用 shutdownNow() 後，會發生這個狀態轉換，這下要清楚 shutDown() 和 shutDownNow() 的區別了；
- SHUTDOWN -> TIDYING：當任務隊列和線程池都清空後，會由 SHUTDOWN 轉換爲 TIDYING；
- STOP -> TIDYING：當任務隊列清空後，發生這個轉換；
- TIDYING -> TERMINATED：這個前面說了，當 terminated() 方法結束後；
2.4 線程池執行
說了那麼多下來一起來看線程池的是怎麼執行任務的，線程池任務提交有兩個方法：
- execute
- submit
其中execute只能接受Runnable類型的任務，使用如下：
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});submit可以接受Runnable或Callable類型的任務，使用如下：
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});2.4.1 帶返回值的線程池實現
使用submit傳遞Callable類可以獲取執行任務的返回值，Callable是JDK 1.5 添加的特性用於補充Runnable無返回的情況。
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Long> result = executorService.submit(new Callable<Long>() {
@Override
public Long call() throws Exception {
return new Date().getTime();
}
});
try {
System.out.println("運行結果：" + result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}2.4.2 延遲線程池實現
在線程池中newSingleThreadScheduledExecutor和newScheduledThreadPool返回的是ScheduledExecutorService，用於執行延遲線程池的，代碼如下：
// 延遲線程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("time:" + new Date().getTime());
}
}, 10, TimeUnit.SECONDS);完整示例下載地址： https://github.com/vipstone/j...
三、線程池源碼解讀
閱讀線程池的源碼有一個小技巧，可以按照線程池執行的順序進行串連關聯閱讀，這樣更容易理解線程池的實現。
源碼閱讀流程解讀
我們先從線程池的任務提交方法execute()開始閱讀，從execute()我們會發現線程池執行的核心方法是addWorker()，在addWorker()中我們發現啓動線程調用了start()方法，調用start()方法之後會執行Worker類的run()方法，run裏面調用runWorker()，運行程序的關鍵在於getTask()方法，getTask()方法之後就是此線程的關閉，整個線程池的工作流程也就完成了，下來一起來看吧（如果本段文章沒看懂的話也可以看完源碼之後，回過頭來再看一遍）。
3.1 execute() 源碼解讀
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 如果當前線程數少於核心線程數，那麼直接添加一個 worker 來執行任務，
// 創建一個新的線程，並把當前任務 command 作爲這個線程的第一個任務(firstTask)
if (workerCountOf(c) < corePoolSize) {
// 添加任務成功，那麼就結束了。提交任務嘛，線程池已經接受了這個任務，這個方法也就可以返回了
// 至於執行的結果，到時候會包裝到 FutureTask 中。
// 返回 false 代表線程池不允許提交任務
if (addWorker(command, true))
return;
c = ctl.get();
}
// 到這裏說明，要麼當前線程數大於等於核心線程數，要麼剛剛 addWorker 失敗了
// 如果線程池處於 RUNNING 狀態，把這個任務添加到任務隊列 workQueue 中
if (isRunning(c) && workQueue.offer(command)) {
/* 這裏面說的是，如果任務進入了 workQueue，我們是否需要開啓新的線程
* 因爲線程數在 [0, corePoolSize) 是無條件開啓新的線程
* 如果線程數已經大於等於 corePoolSize，那麼將任務添加到隊列中，然後進到這裏
*/
int recheck = ctl.get();
// 如果線程池已不處於 RUNNING 狀態，那麼移除已經入隊的這個任務，並且執行拒絕策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 如果線程池還是 RUNNING 的，並且線程數爲 0，那麼開啓新的線程
// 到這裏，我們知道了，這塊代碼的真正意圖是：擔心任務提交到隊列中了，但是線程都關閉了
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 如果 workQueue 隊列滿了，那麼進入到這個分支
// 以 maximumPoolSize 爲界創建新的 worker，
// 如果失敗，說明當前線程數已經達到 maximumPoolSize，執行拒絕策略
else if (!addWorker(command, false))
reject(command);
}3.2 addWorker() 源碼解讀
// 第一個參數是準備提交給這個線程執行的任務，之前說了，可以爲 null
// 第二個參數爲 true 代表使用核心線程數 corePoolSize 作爲創建線程的界線，也就說創建這個線程的時候，
// 如果線程池中的線程總數已經達到 corePoolSize，那麼不能響應這次創建線程的請求
// 如果是 false，代表使用最大線程數 maximumPoolSize 作爲界線
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 這個非常不好理解
// 如果線程池已關閉，並滿足以下條件之一，那麼不創建新的 worker：
// 1. 線程池狀態大於 SHUTDOWN，其實也就是 STOP, TIDYING, 或 TERMINATED
// 2. firstTask != null
// 3. workQueue.isEmpty()
// 簡單分析下：
// 還是狀態控制的問題，當線程池處於 SHUTDOWN 的時候，不允許提交任務，但是已有的任務繼續執行
// 當狀態大於 SHUTDOWN 時，不允許提交任務，且中斷正在執行的任務
// 多說一句：如果線程池處於 SHUTDOWN，但是 firstTask 爲 null，且 workQueue 非空，那麼是允許創建 worker 的
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;
// 由於有併發，重新再讀取一下 ctl
c = ctl.get();
// 正常如果是 CAS 失敗的話，進到下一個裏層的for循環就可以了
// 可是如果是因爲其他線程的操作，導致線程池的狀態發生了變更，如有其他線程關閉了這個線程池
// 那麼需要回到外層的for循環
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
/*
* 到這裏，我們認爲在當前這個時刻，可以開始創建線程來執行任務了，
* 因爲該校驗的都校驗了，至於以後會發生什麼，那是以後的事，至少當前是滿足條件的
*/
// worker 是否已經啓動
boolean workerStarted = false;
// 是否已將這個 worker 添加到 workers 這個 HashSet 中
boolean workerAdded = false;
Worker w = null;
try {
final ReentrantLock mainLock = this.mainLock;
// 把 firstTask 傳給 worker 的構造方法
w = new Worker(firstTask);
// 取 worker 中的線程對象，之前說了，Worker的構造方法會調用 ThreadFactory 來創建一個新的線程
final Thread t = w.thread;
if (t != null) {
// 這個是整個類的全局鎖，持有這個鎖才能讓下面的操作“順理成章”，
// 因爲關閉一個線程池需要這個鎖，至少我持有鎖的期間，線程池不會被關閉
mainLock.lock();
try {
int c = ctl.get();
int rs = runStateOf(c);
// 小於 SHUTTDOWN 那就是 RUNNING，這個自不必說，是最正常的情況
// 如果等於 SHUTDOWN，前面說了，不接受新的任務，但是會繼續執行等待隊列中的任務
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// worker 裏面的 thread 可不能是已經啓動的
if (t.isAlive())
throw new IllegalThreadStateException();
// 加到 workers 這個 HashSet 中
workers.add(w);
int s = workers.size();
// largestPoolSize 用於記錄 workers 中的個數的最大值
// 因爲 workers 是不斷增加減少的，通過這個值可以知道線程池的大小曾經達到的最大值
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 添加成功的話，啓動這個線程
if (workerAdded) {
// 啓動線程
t.start();
workerStarted = true;
}
}
} finally {
// 如果線程沒有啓動，需要做一些清理工作，如前面 workCount 加了 1，將其減掉
if (! workerStarted)
addWorkerFailed(w);
}
// 返回線程是否啓動成功
return workerStarted;
}在這段代碼可以看出，調用了t.start();
3.3 runWorker() 源碼解讀
根據上面代碼可知，調用了Worker的t.start()之後，緊接着會調用Worker的run()方法，run()源碼如下：
public void run() {
runWorker(this);
}runWorker()源碼如下：
// worker 線程啓動後調用,while 循環(即自旋!)不斷從等待隊列獲取任務並執行
// worker 初始化時，可指定 firstTask，那麼第一個任務也就可以不需要從隊列中獲取
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
// 該線程的第一個任務(若有)
Runnable task = w.firstTask;
w.firstTask = null;
// 允許中斷
w.unlock();
boolean completedAbruptly = true;
try {
// 循環調用 getTask 獲取任務
while (task != null || (task = getTask()) != null) {
w.lock();
// 若線程池狀態大於等於 STOP，那麼意味着該線程也要中斷
/**
* 若線程池STOP，請確保線程 已被中斷
* 如果沒有，請確保線程未被中斷
* 這需要在第二種情況下進行重新檢查，以便在關中斷時處理shutdownNow競爭
*/
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) {
// 這裏不允許拋出 Throwable，所以轉換爲 Error
thrown = x; throw new Error(x);
} finally {
// 也是一個鉤子方法，將 task 和異常作爲參數，留給需要的子類實現
afterExecute(task, thrown);
}
} finally {
// 置空 task，準備 getTask 下一個任務
task = null;
// 累加完成的任務數
w.completedTasks++;
// 釋放掉 worker 的獨佔鎖
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 到這裏，需要執行線程關閉
// 1. 說明 getTask 返回 null，也就是說，這個 worker 的使命結束了，執行關閉
// 2. 任務執行過程中發生了異常
// 第一種情況，已經在代碼處理了將 workCount 減 1，這個在 getTask 方法分析中說
// 第二種情況，workCount 沒有進行處理，所以需要在 processWorkerExit 中處理
processWorkerExit(w, completedAbruptly);
}
}3.4 getTask() 源碼解讀
runWorker裏面的有getTask()，來看下具體的實現：
// 此方法有三種可能
// 1. 阻塞直到獲取到任務返回。默認 corePoolSize 之內的線程是不會被回收的，它們會一直等待任務
// 2. 超時退出。keepAliveTime 起作用的時候，也就是如果這麼多時間內都沒有任務，那麼應該執行關閉
// 3. 如果發生了以下條件，須返回 null
// 池中有大於 maximumPoolSize 個 workers 存在(通過調用 setMaximumPoolSize 進行設置)
// 線程池處於 SHUTDOWN，而且 workQueue 是空的，前面說了，這種不再接受新的任務
// 線程池處於 STOP，不僅不接受新的線程，連 workQueue 中的線程也不再執行
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
// 允許核心線程數內的線程回收，或當前線程數超過了核心線程數，那麼有可能發生超時關閉
// 這裏 break，是爲了不往下執行後一個 if (compareAndDecrementWorkerCount(c))
// 兩個 if 一起看：如果當前線程數 wc > maximumPoolSize，或者超時，都返回 null
// 那這裏的問題來了，wc > maximumPoolSize 的情況，爲什麼要返回 null？
// 換句話說，返回 null 意味着關閉線程。
// 那是因爲有可能開發者調用了 setMaximumPoolSize 將線程池的 maximumPoolSize 調小了
// 如果此 worker 發生了中斷，採取的方案是重試
// 解釋下爲什麼會發生中斷，這個讀者要去看 setMaximumPoolSize 方法，
// 如果開發者將 maximumPoolSize 調小了，導致其小於當前的 workers 數量，
// 那麼意味着超出的部分線程要被關閉。重新進入 for 循環，自然會有部分線程會返回 null
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// CAS 操作，減少工作線程數
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) {
// 如果此 worker 發生了中斷，採取的方案是重試
// 解釋下爲什麼會發生中斷，這個讀者要去看 setMaximumPoolSize 方法，
// 如果開發者將 maximumPoolSize 調小了，導致其小於當前的 workers 數量，
// 那麼意味着超出的部分線程要被關閉。重新進入 for 循環，自然會有部分線程會返回 null
timedOut = false;
}
}
}四、線程池執行流程
線程池的執行流程如下圖：
五、總結
本文總結以問答的形式展示，引自《深度解讀 java 線程池設計思想及源碼實現》，最下方附參考地址。
1、線程池有哪些關鍵屬性？
- corePoolSize 到 maximumPoolSize 之間的線程會被回收，當然 corePoolSize 的線程也可以通過設置而得到回收（allowCoreThreadTimeOut(true)）。
- workQueue 用於存放任務，添加任務的時候，如果當前線程數超過了 corePoolSize，那麼往該隊列中插入任務，線程池中的線程會負責到隊列中拉取任務。
- keepAliveTime 用於設置空閒時間，如果線程數超出了 corePoolSize，並且有些線程的空閒時間超過了這個值，會執行關閉這些線程的操作
- rejectedExecutionHandler 用於處理當線程池不能執行此任務時的情況，默認有拋出 RejectedExecutionException 異常、忽略任務、使用提交任務的線程來執行此任務和將隊列中等待最久的任務刪除，然後提交此任務這四種策略，默認爲拋出異常。
2、線程池中的線程創建時機？
- 如果當前線程數少於 corePoolSize，那麼提交任務的時候創建一個新的線程，並由這個線程執行這個任務；
- 如果當前線程數已經達到 corePoolSize，那麼將提交的任務添加到隊列中，等待線程池中的線程去隊列中取任務；
- 如果隊列已滿，那麼創建新的線程來執行任務，需要保證池中的線程數不會超過 maximumPoolSize，如果此時線程數超過了 maximumPoolSize，那麼執行拒絕策略。
3、任務執行過程中發生異常怎麼處理？
如果某個任務執行出現異常，那麼執行任務的線程會被關閉，而不是繼續接收其他任務。然後會啓動一個新的線程來代替它。
4、什麼時候會執行拒絕策略？
- workers 的數量達到了 corePoolSize，任務入隊成功，以此同時線程池被關閉了，而且關閉線程池並沒有將這個任務出隊，那麼執行拒絕策略。這裏說的是非常邊界的問題，入隊和關閉線程池併發執行，讀者仔細看看 execute 方法是怎麼進到第一個 reject(command) 裏面的。
- workers 的數量大於等於 corePoolSize，準備入隊，可是隊列滿了，任務入隊失敗，那麼準備開啓新的線程，可是線程數已經達到 maximumPoolSize，那麼執行拒絕策略。
六、參考資料
書籍：《碼出高效：Java開發手冊》
Java核心技術36講：http://t.cn/EwUJvWA
深度解讀 java 線程池設計思想及源碼實現：https://javadoop.com/post/jav...
Java線程池-ThreadPoolExecutor源碼解析(基於Java8)：https://www.imooc.com/article...
課程推薦：
