@[toc]
引出線程池
線程是并發編程的基礎，前面的文章里，我們的實例基本都是基于線程開發作為實例，并且都是使用的時候就創建一個線程。這種方式比較簡單，但是存在一個問題，那就是線程的數量問題。
假設有一個系統比較復雜，需要的線程數很多，如果都是采用這種方式來創建線程的話，那么就會極大的消耗系統資源。首先是因為線程本身的創建和銷毀需要時間，如果每個小任務都創建一個線程，那么就會大大降低系統的效率。其次是線程本身也是占用內存空間的，大量的線程運行會搶占內存資源，處理不當很可能會內存溢出，這顯然不是我們想看到的。
那么有什么辦法解決呢？有一個好的思路就是對線程進行復用，因為所有的線程并不都是同一時間一起運行的，有些線程在某個時刻可能是空閑狀態，如果這部分空閑線程能有效利用起來，那么就能讓線程的運行被充分的利用，這樣就不需要創建那么多的線程了。我們可以把特定數量的線程放在一個容器里，需要使用線程時，從容器里拿出空閑線程使用，線程工作完后不急著關閉，而是退回到線程池等待使用。這樣的容器一般被稱為線程池。用線程池來管理線程是非常有效的方法，用一張圖片可以簡單的展示出線程池的管理流程：
Executor框架
Java中也有一套框架來控制管理線程，那就是Executor框架。Executor框架是JDK1.5之后才引入的，位于java.util.cocurrent 包下，可以通過該框架來控制線程的啟動、執行和關閉，從而簡化并發編程的操作，這是它的核心成員類圖：
Executor：最上層的接口，定義了一個基本方法execute，接受一個Runnable參數，用來替代通常創建或啟動線程的方法。
ExecutorService：繼承自Executor接口，提供了處理多線程的方法。
ScheduledExecutorService：定時調度接口，繼承自ExecutorService。
AbstractExecutorService：執行框架的抽象類。
ThreadPoolExecutor：線程池中最核心的一個類，提供了線程池操作的基本方法。
Executors：線程池工廠類，可用于創建一系列有特定功能的線程池。
ThreadPoolExecutor詳解
以上Executor框架中的基本成員，其中最核心的的成員無疑就是ThreadPoolExecutor，想了解Java中線程池的運行機制，就必須先了解這個類，而最好的了解方式無疑就是看源碼。
構造函數
打開ThreadPoolExecutor的源碼，發現類中提供了四個構造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
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;
}
可以看出，ThreadPoolExecutor的構造函數中的參數還是比較多的，并且最核心的是第四個構造函數，其中完成了底層的初始化工作。
下面解釋一下構造函數參數的含義：
- corePoolSize：線程池的基本大小。當提交一個任務到線程池后，線程池會創建一個線程執行任務，重復這種操作，直到線程池中的數目達到corePoolSize后不再創建新線程，而是把任務放到緩存隊列中。
- maximumPoolSize：線程池允許創建的最大線程數。
- workQueue：阻塞隊列，用于存儲等待執行的任務，并且只能存儲調用
execute方法提交的任務。常用的有三種隊列，SynchronousQueue，LinkedBlockingDeque，ArrayBlockingQueue。 - keepAliveTime：線程池中線程的最大空閑時間，這種情況一般是線程數目大于任務的數量導致。
- unit：keepAliveTime的時間單位，TimeUnit是一個枚舉類型，位于java.util.concurrent包下。
- threadFactory：線程工廠，用于創建線程。
- handler：拒絕策略，當任務太多來不及處理時所采用的處理策略。
重要的變量
看完了構造函數，我們來看下ThreadPoolExecutor類中幾個重要的成員變量：
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; }
ctl：控制線程運行狀態的一個字段。同時，根據下面的幾個方法runStateOf，workerCountOf，ctlOf可以看出，該字段還包含了兩部分的信息：線程池的運行狀態 (runState) 和線程池內有效線程的數量 (workerCount)，并且使用的是Integar類型，高3位保存runState，低29位保存workerCount。
COUNT_BITS：值為29的常量，在字段CAPACITY被引用計算。
CAPACITY：表示有效線程數量(workerCount)的上限，大小為 (1<<29) - 1。
下面5個變量表示的是線程的運行狀態，分別是：
- RUNNING ：接受新提交的任務，并且能處理阻塞隊列中的任務；
- SHUTDOWN：不接受新的任務，但會執行隊列中的任務。
- STOP：不接受新任務，也不處理隊列中的任務，同時中斷正在處理任務的線程。
- TIDYING：如果所有的任務都已終止了，workerCount (有效線程數) 為0，線程池進入該狀態后會調用 terminated() 方法進入TERMINATED 狀態。
- TERMINATED：terminated( ) 方法執行完畢。
用一個狀態轉換圖表示大概如下 (圖片來源于https://www.cnblogs.com/liuzhihu/p/8177371.html)：
構造函數和基本參數都了解后，接下來就是對類中重要方法的研究了。
線程池執行流程
execute方法
ThreadPoolExecutor類的核心調度方法是execute()，通過調用這個方法可以向線程池提交一個任務，交由線程池去執行。而ThreadPoolExecutor的工作邏輯也可以藉由這個方法來一步步理清。這是方法的源碼：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//獲取ctl的值，前面說了，該值記錄著runState和workerCount
int c = ctl.get();
/*
* 調用workerCountOf得到當前活動的線程數；
* 當前活動線程數小于corePoolSize，新建一個線程放入線程池中；
* addWorker(): 把任務添加到該線程中。
*/
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
//如果上面的添加線程操作失敗，重新獲取ctl值
c = ctl.get();
}
//如果當前線程池是運行狀態，并且往工作隊列中添加該任務
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
/*
* 如果當前線程不是運行狀態，把任務從隊列中移除
* 調用reject(內部調用handler)拒絕接受任務
*/
if (! isRunning(recheck) && remove(command))
reject(command);
//獲取線程池中的有效線程數，如果為0，則執行addWorker創建一個新線程
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
/*
* 如果執行到這里，有兩種情況：
* 1. 線程池已經不是RUNNING狀態；
* 2. 線程池是RUNNING狀態，但workerCount >= corePoolSize并且workQueue已滿。
* 這時，再次調用addWorker方法，但第二個參數傳入為false，將線程池的有限線程數量的上限設置為maximumPoolSize；
* 如果失敗則拒絕該任務
*/
else if (!addWorker(command, false))
reject(command);
}
簡單概括一下代碼的邏輯，大概是這樣：
1、判斷當前運行中的線程數是否小于corePoolSize，是的話則調用addWorker創建線程執行任務。
2、不滿足1的條件，就把任務放入工作隊列workQueue中。
3、如果任務成功加入workQueue，判斷線程池是否是運行狀態，不是的話先把任務移出工作隊列，并調用reject方法，使用拒絕策略拒絕該任務。線程如果是非運行中，調用addWorker創建一個新線程。
4、如果放入workQueue失敗 (隊列已滿)，則調用addWorker創建線程執行任務，如果這時創建線程失敗 (addWorker傳進去的第二個參數值是false，說明這種情況是當前線程數不小于maximumPoolSize)，就會調用reject(內部調用handler)拒絕接受任務。
整個執行流程用一張圖片表示大致如下：
以上就是execute方法的大概邏輯，接下來看看addWorker的方法實現。
addWorker方法
源碼如下：
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/**線程池狀態不為SHUTDOWN時
* 判斷隊列或者任務是否為空，是的話返回false
*/.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
/* 這里可以看出core參數決定著活動線程數的大小比較對象
* core為true表示與 corePoolSize大小進行比較
* core為false表示與 maximumPoolSize大小進行比較
* 當前活動線程數大于比較對象就返回false
*/
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 嘗試增加workerCount，如果成功，則跳出第一個for循環
if (compareAndIncrementWorkerCount(c))
break retry;
// 如果增加workerCount失敗，則重新獲取ctl的值
c = ctl.get(); // Re-read ctl
// 如果當前的運行狀態不等于rs，說明狀態已被改變，返回第一個for循環繼續執行
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 {
//創建一個worker對象w
w = new Worker(firstTask);
//實例化w的線程t
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();
// workers是一個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)
addWorkerFailed(w);
}
return workerStarted;
}
從代碼中可以看出，addWorker方法的主要工作是在線程池中創建一個新的線程并執行，其中firstTask參數指定的是新線程需要執行的第一個任務，core參數決定于活動線程數的比較對象是corePoolSize還是maximumPoolSize。根據傳進來的參數首先對線程池和隊列的狀態進行判斷，滿足條件就新建一個Worker對象，并實例化該對象的線程，最后啟動線程。
Worker類
根據addWorker源碼中的邏輯，我們可以發現，線程池中的每一個線程其實都是對應的Worker對象在維護的，所以我們有必要對Worker類一探究竟，先看一下類的源碼：
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** 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;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
從Worker類的構造函數可以看出，當實例化一個Worker對象時，Worker對象會把傳進來的Runnable參數firstTask賦值給自己的同名屬性，并且用線程工廠也就是當前的ThreadFactory來新建一個線程。
同時，因為Worker實現了Runnable接口，所以當Worker類中的線程啟動時，調用的其實是run()方法。run方法中調用的是runWorker方法，我們來看下它的具體實現：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
//獲取第一個任務
Runnable task = w.firstTask;
w.firstTask = null;
//允許中斷
w.unlock(); // allow interrupts
//是否因為異常退出循環的標志，processWorkerExit方法會對該參數做判斷
boolean completedAbruptly = true;
try {
//判斷task是否為null，是的話通過getTask()從隊列中獲取任務
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
/* 這里的判斷主要邏輯是這樣：
* 如果線程池正在停止，那么就確保當前線程是中斷狀態；
* 如果不是的話，就要保證不是中斷狀態
*/
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//用于記錄任務執行前需要做哪些事，屬于ThreadPoolExecutor類中的方法， //是空的，需要子類具體實現
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);
}
}
總結一下runWorker方法的運行邏輯：
1、通過while循環不斷地通過getTask()方法從隊列中獲取任務；
2、如果線程池正在停止狀態，確保當前的線程是中斷狀態，否則確保當前線程不中斷；
3、調用task的run()方法執行任務，執行完畢后需要置為null；
4、循環調用getTask()取不到任務了，跳出循環，執行processWorkerExit()方法。
過完runWorker()的運行流程，我們來看下getTask()是怎么實現的。
getTask方法
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())) {
//將workerCount減1
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
/* timed變量用于判斷線程的操作是否需要進行超時判斷
* allowCoreThreadTimeOut不管它，默認是false
* wc > corePoolSize，當前線程是如果大于核心線程數corePoolSize
*/
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
/* 根據timed變量判斷，如果為true，調用workQueue的poll方法獲取任務，
* 如果在keepAliveTime時間內沒有獲取到任務，則返回null；
* timed為false的話，就調用workQueue的take方法阻塞隊列，
* 直到隊列中有任務可取。
*/
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
//r為null，說明time為true，超時了，把timedOut也設置為true
timedOut = true;
} catch (InterruptedException retry) {
//發生異常，把timedOut也設置為false，重新跑循環
timedOut = false;
}
}
}
getTask的代碼看上去比較簡單，但其實內有乾坤，我們來重點分析一下兩個if判斷的邏輯：
1、當進入getTask方法后，先判斷當前線程池狀態，如果線程池狀態rs >= SHUTDOWN，再進行以下判斷：
1）rs 的狀態是否大于STOP；2）隊列是否為空；
滿足以上條件其中之一，就將workerCount減1并返回null，也就是表示隊列中不再有任務。因為線程池的狀態值是SHUTDOWN以上時，隊列中不再允許添加新任務，所以上面兩個條件滿足一個都說明隊列中的任務都取完了。
2、進入第二個if判斷，這里的邏輯有點繞，但作用比較重要，是為了控制線程池的有效線程數量，我們來具體解析下代碼：
wc > maximumPoolSize：判斷當前線程數是否大于maximumPoolSize，這種情況一般很少發生，除非是maximumPoolSize的大小在該程序執行的同時被進行設置，比如調用ThreadPoolExecutor中的setMaximumPoolSize方法。
timed && timedOut：如果為true，表示當前的操作需要進行超時判斷，并且上次從隊列獲取任務已經超時。
wc > 1 || workQueue.isEmpty()：如果工作線程大于1，或者阻塞隊列是空的。
compareAndDecrementWorkerCount：比較并將線程池中的workerCount減1
在上文中，我們解析execute方法的邏輯時了解到，如果當前線程池的線程數量超過了corePoolSize且小于maximumPoolSize，并且workQueue已滿時，仍然可以增加工作線程。
但調用getTask()取任務的過程中，如果超時沒有獲取到任務，也就是timedOut為true的情況，說明workQueue已經為空了，也就說明了當前線程池中不需要那么多線程來執行任務了，可以把多于corePoolSize數量的線程銷毀掉，也就是不斷的讓任務被取出，讓線程數量保持在corePoolSize即可，直到getTask方法返回null。
而當getTask方法返回null后，runWorker方法中就會因為取不到任務而執行processWorkerExit()方法。
processWorkerExit方法
processWorkerExit方法的作用主要是對worker對象的移除，下面是方法的源碼：
private void processWorkerExit(Worker w, boolean completedAbruptly) {
//是異常退出的話，執行程序將workerCount數量減1
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
// 從workers的集合中移除worker對象，也就表示著從線程池中移除了一個工作線程
workers.remove(w);
} finally {
mainLock.unlock();
}
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
至此，從executor方法開始的整個運行過程就完畢了，總結一下該流程：
執行executor --> 新建Worker對象，并實例化線程 --> 調用runWorker方法，通過getTask()獲取任務，并執行run方法 --> getTask()方法中不斷向隊列取任務，并將workerCount數量減1，直至返回null --> 調用processWorkerExit清除worker對象。
用一張流程圖表示如下所示 (圖片來源于https://www.cnblogs.com/liuzhihu/p/8177371.html)：
任務隊列workQueue
前面我們多次提到了workQueue，這是一個任務隊列，用來存放等待執行的任務，它是BlockingQueue<Runnable>類型的對象，而在ThreadPoolExecutor的源碼注釋中，詳細介紹了三種常用的Queue類型，分別是：
SynchronousQueue：直接提交的隊列。這個隊列沒有容量，當接收到任務的時候，會直接提交給線程處理，而不保留它。如果沒有空閑的線程，就新建一個線程來處理這個任務！如果線程數量達到最大值，就會執行拒絕策略。所以，使用這個類型隊列的時候，一般都是將maximumPoolSize一般指定成Integer.MAX_VALUE，避免容易被拒絕。
ArrayBlockingQueue：有界的任務隊列。需要給定一個參數來限制隊列的長度，接收到任務的時候，如果沒有達到corePoolSize的值，則新建線程 (核心線程) 執行任務，如果達到了，則將任務放入等待隊列。如果隊列已滿，則在總線程數不到maximumPoolSize的前提下新建線程執行任務，若大于maximumPoolSize，則執行拒絕策略。
LinkedBlockingQueue：無界的任務隊列。該隊列沒有任務數量的限制，所以任務可以一直入隊，知道耗盡系統資源。當接收任務，如果當前線程數小于corePoolSize，則新建線程處理任務；如果當前線程數等于corePoolSize，則進入隊列等待。
任務拒絕策略
當線程池的任務隊列已滿并且線程數目達到maximumPoolSize時，對于新加的任務一般會采取拒絕策略，通常有以下四種策略：
- AbortPolicy：直接拋出異常，這是默認策略；
- CallerRunsPolicy：用調用者所在的線程來執行任務；
- DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，并執行當前任務；
- DiscardPolicy：直接丟棄任務；
線程池的關閉
ThreadPoolExecutor提供了兩個方法，用于線程池的關閉，分別是shutdown()和shutdownNow()：
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
tryTerminate();
}
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
代碼邏輯就不一一進行解析了，總結一下兩個方法的特點就是：
- shutdown()：不會立即終止線程池，而是要等所有任務緩存隊列中的任務都執行完后才終止，但再也不會接受新的任務
- shutdownNow()：立即終止線程池，并嘗試打斷正在執行的任務，并且清空任務緩存隊列，返回尚未執行的任務
ThreadPoolExecutor創建線程池實例
ThreadPoolExecutor的運行機制講完了，接下來展示一下如何用ThreadPoolExecutor創建線程池實例，具體代碼如下：
public static void main(String[] args) {
ExecutorService service = new ThreadPoolExecutor(5, 10, 300, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<Runnable>(5));
//用lambda表達式編寫方法體中的邏輯
Runnable run = () -> {
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "正在執行");
} catch (InterruptedException e) {
e.printStackTrace();
}
};
for (int i = 0; i < 10; i++) {
service.execute(run);
}
//這里一定要做關閉
service.shutdown();
}
上面的代碼中，我們創建的ThreadPoolExecutor線程池的核心線程數為5個，所以，當調用線程池執行任務時，同時運行的線程最多也是5個，執行main方法，輸出結果如下：
pool-1-thread-3正在執行
pool-1-thread-1正在執行
pool-1-thread-4正在執行
pool-1-thread-5正在執行
pool-1-thread-3正在執行
pool-1-thread-2正在執行
pool-1-thread-1正在執行
pool-1-thread-4正在執行
pool-1-thread-5正在執行
看到出來，線程池確實只有5個線程在工作，也就是真正的實現了線程的復用，說明我們的ThreadPoolExecutor實例是有效的。
參考：
https://www.cnblogs.com/liuzhihu/p/8177371.html
https://www.cnblogs.com/dolphin0520/p/3932921.html
《實戰Java：高并發程序設計》
