參考地址: https://mp.weixin.qq.com/s/zKClZIv1TWNPHpxK2nvNJw

Java 中的 ThreadPoolExecutor 類

java.uitl.concurrent.ThreadPoolExecutor 類是執行緒池中最核心的一個類，因此如果要透徹地瞭解Java 中的執行緒池，必須先了解這個類。

下面我們來看一下 ThreadPoolExecutor 類的具體實現原始碼。

在 ThreadPoolExecutor 類中提供了四個構造方法：

 public class ThreadPoolExecutor extends AbstractExecutorService {
 .....
 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
 BlockingQueue<Runnable> workQueue);
 
 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
 BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
 BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

 public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
 BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
 ...
 }
 

從上面的程式碼可以得知，ThreadPoolExecutor 繼承了 AbstractExecutorService 類，並提供了四個構造器，

事實上，通過觀察每個構造器的原始碼具體實現，發現前面三個構造器都是呼叫的第四個構造器進行的初始化工作。

下面解釋下一下構造器中各個引數的含義：

corePoolSize：

核心池的大小，這個引數跟後面講述的執行緒池的實現原理有非常大的關係。在建立了執行緒池後，預設情況下，執行緒池中並沒有任何執行緒，而是等待有任務到來才建立執行緒去執行任務，

除非呼叫了prestartAllCoreThreads() 或者 prestartCoreThread()方法，從這 2 個方法的名字就可以看出，是預建立執行緒的意思，即在沒有任務到來之前就建立 corePoolSize 個執行緒或者一個執行緒。

預設情況下，在建立了執行緒池後，執行緒池中的執行緒數為0，當有任務來之後，就會建立一個執行緒去執行任務，當執行緒池中的執行緒數目達到 corePoolSize 後，就會把到達的任務放到快取隊列當中；

maximumPoolSize：

執行緒池最大執行緒數，這個引數也是一個非常重要的引數，它表示線上程池中最多能建立多少個執行緒；

keepAliveTime：

表示執行緒沒有任務執行時最多保持多久時間會終止。預設情況下，只有當執行緒池中的執行緒數大於 corePoolSize 時，keepAliveTime 才會起作用，直到執行緒池中的執行緒數不大於 corePoolSize，

即當執行緒池中的執行緒數大於 corePoolSize 時，如果一個執行緒空閒的時間達到 keepAliveTime，則會終止，直到執行緒池中的執行緒數不超過 corePoolSize。

但是如果呼叫了 allowCoreThreadTimeOut(boolean)

unit：

引數 keepAliveTime 的時間單位，有 7 種取值，在 TimeUnit 類中有 7 種靜態屬性：

TimeUnit.DAYS; //天
TimeUnit.HOURS; //小時
TimeUnit.MINUTES; //分鐘
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //納秒

• workQueue:

• 一個阻塞佇列，用來儲存等待執行的任務，這個引數的選擇也很重要，會對執行緒池的執行過程產生重大影響，一般來說，這裡的阻塞佇列有以下幾種選擇：

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

ArrayBlockingQueue 和 PriorityBlockingQueue 使用較少，一般使用 LinkedBlockingQueue 和 Synchronous。執行緒池的排隊策略與 BlockingQueue 有關。

threadFactory：

執行緒工廠，主要用來建立執行緒；

handler：

表示當拒絕處理任務時的策略，有以下四種取值：

ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException異常。 
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不丟擲異常。 
ThreadPoolExecutor.DiscardOldestPolicy：丟棄佇列最前面的任務，然後重新嘗試執行任務（重複此過程）
ThreadPoolExecutor.CallerRunsPolicy：由呼叫執行緒處理該任務 

具體引數的配置與執行緒池的關係將在下一節講述。

從上面給出的 ThreadPoolExecutor 類的程式碼可以知道，ThreadPoolExecutor 繼承了AbstractExecutorService，我們來看一下 AbstractExecutorService 的實現：

 public abstract class AbstractExecutorService implements ExecutorService {
 
 
 protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };
 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };
 public Future<?> submit(Runnable task) {};
 public <T> Future<T> submit(Runnable task, T result) { };
 public <T> Future<T> submit(Callable<T> task) { };
 private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
 boolean timed, long nanos)
 throws InterruptedException, ExecutionException, TimeoutException {
 };
 public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
 throws InterruptedException, ExecutionException {
 };
 public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException {
 };
 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
 throws InterruptedException {
 };
 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException {
 };
 } 

AbstractExecutorService 是一個抽象類，它實現了 ExecutorService 介面。

我們接著看 ExecutorService 介面的實現：

 public interface ExecutorService extends Executor {
 
 void shutdown();
 boolean isShutdown();
 boolean isTerminated();
 boolean awaitTermination(long timeout, TimeUnit unit)
 throws InterruptedException;
 <T> Future<T> submit(Callable<T> task);
 <T> Future<T> submit(Runnable task, T result);
 Future<?> submit(Runnable task);
 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
 throws InterruptedException;
 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException;
 
 <T> T invokeAny(Collection<? extends Callable<T>> tasks)
 throws InterruptedException, ExecutionException;
 <T> T invokeAny(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException;
 }

而 ExecutorService 又是繼承了 Executor 介面，我們看一下 Executor 介面的實現：

public interface Executor {
 void execute(Runnable command);
}

到這裡，大家應該明白了 ThreadPoolExecutor、AbstractExecutorService、ExecutorService 和 Executor幾個之間的關係了。

Executor 是一個頂層介面，在它裡面只聲明瞭一個方法 execute(Runnable)，返回值為 void，引數為Runnable 型別，從字面意思可以理解，就是用來執行傳進去的任務的；

然後 ExecutorService 介面繼承了 Executor 介面，並聲明瞭一些方法：submit、invokeAll、invokeAny 以及shutDown 等；

抽象類AbstractExecutorService實現了 ExecutorService 介面，基本實現了 ExecutorService 中宣告的所有方法；

然後ThreadPoolExecutor 繼承了類 AbstractExecutorService。

在 ThreadPoolExecutor 類中有幾個非常重要的方法：

execute()
submit()
shutdown()
shutdownNow()

execute() 方法實際上是 Executor 中宣告的方法，在 ThreadPoolExecutor 進行了具體的實現，這個方法是ThreadPoolExecutor 的核心方法，通過這個方法可以向執行緒池提交一個任務，交由執行緒池去執行。

submit()方法是在 ExecutorService 中宣告的方法，在 AbstractExecutorService 就已經有了具體的實現，在ThreadPoolExecutor 中並沒有對其進行重寫，這個方法也是用來向執行緒池提交任務的，

但是它和 execute() 方法不同，它能夠返回任務執行的結果，去看 submit() 方法的實現，會發現它實際上還是呼叫的 execute() 方法，只不過它利用了 Future 來獲取任務執行結果（Future相關內容將在下一篇講述）。

shutdown()和shutdownNow()是用來關閉執行緒池的。

還有很多其他的方法：

比如：getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount() 等獲取與執行緒池相關屬性的方法，有興趣的朋友可以自行查閱 API。

深入剖析執行緒池實現原理

　　在上一節我們從巨集觀上介紹了 ThreadPoolExecutor，下面我們來深入解析一下執行緒池的具體實現原理，將從下面幾個方面講解：

1.執行緒池狀態

2.任務的執行

3.執行緒池中的執行緒初始化

4.任務快取佇列及排隊策略

5.任務拒絕策略

6.執行緒池的關閉

7.執行緒池容量的動態調整

執行緒池狀態

在 ThreadPoolExecutor 中定義了一個 volatile 變數，另外定義了幾個 static final 變量表示執行緒池的各個狀態：

volatile int runState;
static final int RUNNING = 0;
static final int SHUTDOWN = 1;
static final int STOP = 2;
static final int TERMINATED = 3;

runState 表示當前執行緒池的狀態，它是一個 volatile 變數用來保證執行緒之間的可見性；

下面的幾個 static final 變量表示 runState 可能的幾個取值。

當建立執行緒池後，初始時，執行緒池處於 RUNNING 狀態；

如果呼叫了 shutdown() 方法，則執行緒池處於 SHUTDOWN 狀態，此時執行緒池不能夠接受新的任務，它會等待所有任務執行完畢；

如果呼叫了shutdownNow()方法，則執行緒池處於STOP狀態，此時執行緒池不能接受新的任務，並且會去嘗試終止正在執行的任務；

當執行緒池處於 SHUTDOWN 或 STOP 狀態，並且所有工作執行緒已經銷燬，任務快取佇列已經清空或執行結束後，執行緒池被設定為TERMINATED狀態。

任務的執行

在瞭解將任務提交給執行緒池到任務執行完畢整個過程之前，我們先來看一下 ThreadPoolExecutor 類中其他的一些比較重要成員變數：

 private final BlockingQueue<Runnable> workQueue; //任務快取佇列，用來存放等待執行的任務
 private final ReentrantLock mainLock = new ReentrantLock(); //執行緒池的主要狀態鎖，對執行緒池狀態（比如執行緒池大小
 //、runState等）的改變都要使用這個鎖
 private final HashSet<Worker> workers = new HashSet<Worker>(); //用來存放工作集
 
 private volatile long keepAliveTime; //執行緒存貨時間 
 private volatile boolean allowCoreThreadTimeOut; //是否允許為核心執行緒設定存活時間
 private volatile int corePoolSize; //核心池的大小（即執行緒池中的執行緒數目大於這個引數時，提交的任務會被放進任務快取佇列）
 private volatile int maximumPoolSize; //執行緒池最大能容忍的執行緒數

 private volatile int poolSize; //執行緒池中當前的執行緒數

 private volatile RejectedExecutionHandler handler; //任務拒絕策略

 private volatile ThreadFactory threadFactory; //執行緒工廠，用來建立執行緒

 private int largestPoolSize; //用來記錄執行緒池中曾經出現過的最大執行緒數

 private long completedTaskCount; //用來記錄已經執行完畢的任務個數

每個變數的作用都已經標明出來了，這裡要重點解釋一下 corePoolSize、maximumPoolSize、largestPoolSize 三個變數。

corePoolSize 在很多地方被翻譯成核心池大小，其實我的理解這個就是執行緒池的大小。舉個簡單的例子：

假如有一個工廠，工廠裡面有 10 個工人，每個工人同時只能做一件任務。

因此只要當 10 個工人中有工人是空閒的，來了任務就分配給空閒的工人做；

當 10 個工人都有任務在做時，如果還來了任務，就把任務進行排隊等待；

如果說新任務數目增長的速度遠遠大於工人做任務的速度，那麼此時工廠主管可能會想補救措施，比如重新招4個臨時工人進來；

然後就將任務也分配給這 4 個臨時工人做；

如果說著 14 個工人做任務的速度還是不夠，此時工廠主管可能就要考慮不再接收新的任務或者拋棄前面的一些任務了。

當這 14 個工人當中有人空閒時，而新任務增長的速度又比較緩慢，工廠主管可能就考慮辭掉 4 個臨時工了，只保持原來的10個工人，畢竟請額外的工人是要花錢的。

這個例子中的 corePoolSize 就是 10，而 maximumPoolSize 就是14（10+4）。

也就是說 corePoolSize 就是執行緒池大小，maximumPoolSize 在我看來是執行緒池的一種補救措施，即任務量突然過大時的一種補救措施。

不過為了方便理解，在本文後面還是將 corePoolSize 翻譯成核心池大小。

largestPoolSize 只是一個用來起記錄作用的變數，用來記錄執行緒池中曾經有過的最大執行緒數目，跟執行緒池的容量沒有任何關係。

下面我們進入正題，看一下任務從提交到最終執行完畢經歷了哪些過程。

在 ThreadPoolExecutor 類中，最核心的任務提交方法是 execute() 方法，雖然通過 submit 也可以提交任務，但是實際上 submit 方法裡面最終呼叫的還是 execute() 方法，

所以我們只需要研究 execute() 方法的實現原理即可：

 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
 }
 }

上面的程式碼可能看起來不是那麼容易理解，下面我們一句一句解釋：

首先，判斷提交的任務 command 是否為 null，若是 null，則丟擲空指標異常；

接著是這句，這句要好好理解一下：

if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))

由於是或條件運算子，所以先計算前半部分的值，如果執行緒池中當前執行緒數不小於核心池大小，那麼就會直接進入下面的if語句塊了。

如果執行緒池中當前執行緒數小於核心池大小，則接著執行後半部分，也就是執行

addIfUnderCorePoolSize(command)

如果執行完 addIfUnderCorePoolSize 這個方法返回 false，則繼續執行下面的 if 語句塊，否則整個方法就直接執行完畢了。

如果執行完 addIfUnderCorePoolSize 這個方法返回 false，然後接著判斷：

if (runState == RUNNING && workQueue.offer(command))

如果當前執行緒池處於 RUNNING 狀態，則將任務放入任務快取佇列；如果當前執行緒池不處於 RUNNING 狀態或者任務放入快取佇列失敗，則執行：

addIfUnderMaximumPoolSize(command)

如果執行 addIfUnderMaximumPoolSize 方法失敗，則執行 reject() 方法進行任務拒絕處理。

回到前面：

if (runState == RUNNING && workQueue.offer(command))

這句的執行，如果說當前執行緒池處於RUNNING狀態且將任務放入任務快取佇列成功，則繼續進行判斷：

if (runState != RUNNING || poolSize == 0)

這句判斷是為了防止在將此任務新增進任務快取佇列的同時其他執行緒突然呼叫 shutdown 或者 shutdownNow 方法關閉了執行緒池的一種應急措施。如果是這樣就執行：

ensureQueuedTaskHandled(command)

進行應急處理，從名字可以看出是保證新增到任務快取佇列中的任務得到處理。

我們接著看 2 個關鍵方法的實現：addIfUnderCorePoolSize 和 addIfUnderMaximumPoolSize：

 private boolean addIfUnderCorePoolSize(Runnable firstTask) {
 Thread t = null;
 final ReentrantLock mainLock = this.mainLock;
 mainLock.lock();
 try {
 if (poolSize < corePoolSize && runState == RUNNING)
 t = addThread(firstTask); //建立執行緒去執行firstTask任務 
 } finally {
 mainLock.unlock();
 }
 if (t == null)
 return false;
 t.start();
 return true;
 }

這個是 addIfUnderCorePoolSize 方法的具體實現，從名字可以看出它的意圖就是當低於核心吃大小時執行的方法。

下面看其具體實現，首先獲取到鎖，因為這地方涉及到執行緒池狀態的變化，先通過 if 語句判斷當前執行緒池中的執行緒數目是否小於核心池大小，有朋友也許會有疑問：

前面在 execute() 方法中不是已經判斷過了嗎，只有執行緒池當前執行緒數目小於核心池大小才會執行 addIfUnderCorePoolSize 方法的，為何這地方還要繼續判斷？

原因很簡單，前面的判斷過程中並沒有加鎖，因此可能在execute方法判斷的時候 poolSize 小於 corePoolSize，而判斷完之後，在其他執行緒中又向執行緒池提交了任務，

就可能導致 poolSize 不小於 corePoolSize 了，所以需要在這個地方繼續判斷。

然後接著判斷執行緒池的狀態是否為 RUNNING，原因也很簡單，因為有可能在其他執行緒中呼叫了shutdown 或者 shutdownNow 方法。然後就是執行

t = addThread(firstTask);

這個方法也非常關鍵，傳進去的引數為提交的任務，返回值為Thread型別。然後接著在下面判斷 t 是否為空，

為空則表明建立執行緒失敗（即 poolSize >= corePoolSize 或者 runState 不等於 RUNNING），否則呼叫 t.start() 方法啟動執行緒。

我們來看一下addThread方法的實現：

 private Thread addThread(Runnable firstTask) {
 Worker w = new Worker(firstTask);
 Thread t = threadFactory.newThread(w); //建立一個執行緒，執行任務 
 if (t != null) {
 w.thread = t; //將建立的執行緒的引用賦值為w的成員變數 
 workers.add(w);
 int nt = ++poolSize; //當前執行緒數加1 
 if (nt > largestPoolSize)
 largestPoolSize = nt;
 }
 return t;
 }

在 addThread 方法中，首先用提交的任務建立了一個 Worker 物件，然後呼叫執行緒工廠 threadFactory 建立了一個新的執行緒 t，

然後將執行緒t的引用賦值給了 Worker 物件的成員變數 thread，接著通過 workers.add(w) 將 Worker物件新增到工作集當中。

下面我們看一下 Worker 類的實現：

 private final class Worker implements Runnable {
 private final ReentrantLock runLock = new ReentrantLock();
 private Runnable firstTask;
 volatile long completedTasks;
 Thread thread;
 Worker(Runnable firstTask) {
 this.firstTask = firstTask;
 }
 boolean isActive() {
 return runLock.isLocked();
 }
 void interruptIfIdle() {
 final ReentrantLock runLock = this.runLock;
 if (runLock.tryLock()) {
 try {
 if (thread != Thread.currentThread())
 thread.interrupt();
 } finally {
 runLock.unlock();
 }
 }
 }
 void interruptNow() {
 thread.interrupt();
 }
 
 private void runTask(Runnable task) {
 final ReentrantLock runLock = this.runLock;
 runLock.lock();
 try {
 if (runState < STOP &&
 Thread.interrupted() &&
 runState >= STOP)
 boolean ran = false;
 beforeExecute(thread, task); //beforeExecute方法是ThreadPoolExecutor類的一個方法，沒有具體實現，使用者可以根據
 //自己需要過載這個方法和後面的afterExecute方法來進行一些統計資訊，比如某個任務的執行時間等 
 try {
 task.run();
 ran = true;
 afterExecute(task, null);
 ++completedTasks;
 } catch (RuntimeException ex) {
 if (!ran)
 afterExecute(task, ex);
 throw ex;
 }
 } finally {
 runLock.unlock();
 }
 }
 
 public void run() {
 try {
 Runnable task = firstTask;
 firstTask = null;
 while (task != null || (task = getTask()) != null) {
 runTask(task);
 task = null;
 }
 } finally {
 workerDone(this); //當任務佇列中沒有任務時，進行清理工作 
 }
 }
 }

它實際上實現了 Runnable 介面，因此上面的 Thread t = threadFactory.newThread(w) 效果跟下面這句的效果基本一樣：

Thread t = new Thread(w);

相當於傳進去了一個Runnable 任務，線上程t中執行這個 Runnable。

既然 Worker 實現了 Runnable 介面，那麼自然最核心的方法便是 run() 方法了：

 public void run() {
 try {
 Runnable task = firstTask;
 firstTask = null;
 while (task != null || (task = getTask()) != null) {
 runTask(task);
 task = null;
 }
 } finally {
 workerDone(this);
 }
 }

從 run 方法的實現可以看出，它首先執行的是通過構造器傳進來的任務 firstTask，在呼叫 runTask() 執行完firstTask 之後，在 while 迴圈裡面不斷通過 getTask() 去取新的任務來執行，

那麼去哪裡取呢？自然是從任務快取佇列裡面去取，getTask 是 ThreadPoolExecutor 類中的方法，並不是 Worker 類中的方法，下面是 getTask 方法的實現：

 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) //如果執行緒數大於核心池大小或者允許為核心池執行緒設定空閒時間，
 //則通過poll取任務，若等待一定的時間取不到任務，則返回null
 r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
 else
 r = workQueue.take();
 if (r != null)
 return r;
 if (workerCanExit()) { //如果沒取到任務，即r為null，則判斷當前的worker是否可以退出
 if (runState >= SHUTDOWN) // Wake up others
 interruptIdleWorkers(); //中斷處於空閒狀態的worker
 return null;
 }
 // Else retry
 } catch (InterruptedException ie) {
 // On interruption, re-check runState
 }
 }
 }

在 getTask 中，先判斷當前執行緒池狀態，如果 runState 大於 SHUTDOWN（即為 STOP 或者 TERMINATED），則直接返回 null。

如果 runState 為 SHUTDOWN 或者 RUNNING，則從任務快取佇列取任務。

如果當前執行緒池的執行緒數大於核心池大小 corePoolSize 或者允許為核心池中的執行緒設定空閒存活時間，則呼叫poll(time,timeUnit)來取任務，這個方法會等待一定的時間，如果取不到任務就返回 null。

然後判斷取到的任務 r 是否為 null，為 null 則通過呼叫 workerCanExit() 方法來判斷當前 worker 是否可以退出，我們看一下 workerCanExit() 的實現：

 private boolean workerCanExit() {
 final ReentrantLock mainLock = this.mainLock;
 mainLock.lock();
 boolean canExit;
 //如果runState大於等於STOP，或者任務快取佇列為空了
 //或者 允許為核心池執行緒設定空閒存活時間並且執行緒池中的執行緒數目大於1
 try {
 canExit = runState >= STOP ||
 workQueue.isEmpty() ||
 (allowCoreThreadTimeOut &&
 poolSize > Math.max(1, corePoolSize));
 } finally {
 mainLock.unlock();
 }
 return canExit;
 }

也就是說如果執行緒池處於 STOP 狀態、或者任務佇列已為空或者允許為核心池執行緒設定空閒存活時間並且執行緒數大於 1 時，允許 worker 退出。

如果允許 worker 退出，則呼叫interruptIdleWorkers()中斷處於空閒狀態的 worker，我們看一下 interruptIdleWorkers() 的實現：

 void interruptIdleWorkers() {
 final ReentrantLock mainLock = this.mainLock;
 mainLock.lock();
 try {
 for (Worker w : workers) //實際上呼叫的是worker的interruptIfIdle()方法
 w.interruptIfIdle();
 } finally {
 mainLock.unlock();
 }
 }

從實現可以看出，它實際上呼叫的是 worker 的 interruptIfIdle()方法，在 worker 的 interruptIfIdle() 方法中：

 void interruptIfIdle() {
 final ReentrantLock runLock = this.runLock;
 if (runLock.tryLock()) { //注意這裡，是呼叫tryLock()來獲取鎖的，因為如果當前worker正在執行任務，鎖已經被獲取了，是無法獲取到鎖的
 //如果成功獲取了鎖，說明當前worker處於空閒狀態
 try {
 if (thread != Thread.currentThread()) 
 thread.interrupt();
 } finally {
 runLock.unlock();
 }
 }
 }

這裡有一個非常巧妙的設計方式，假如我們來設計執行緒池，可能會有一個任務分派執行緒，當發現有執行緒空閒時，就從任務快取佇列中取一個任務交給空閒執行緒執行。

但是在這裡，並沒有採用這樣的方式，因為這樣會要額外地對任務分派執行緒進行管理，無形地會增加難度和複雜度，這裡直接讓執行完任務的執行緒去任務快取佇列裡面取任務來執行。

我們再看 addIfUnderMaximumPoolSize 方法的實現，這個方法的實現思想和 addIfUnderCorePoolSize 方法的實現思想非常相似，

唯一的區別在於 addIfUnderMaximumPoolSize 方法是線上程池中的執行緒數達到了核心池大小並且往任務佇列中新增任務失敗的情況下執行的：

 private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
 Thread t = null;
 final ReentrantLock mainLock = this.mainLock;
 mainLock.lock();
 try {
 if (poolSize < maximumPoolSize && runState == RUNNING)
 t = addThread(firstTask);
 } finally {
 mainLock.unlock();
 }
 if (t == null)
 return false;
 t.start();
 return true;
 }

看到沒有，其實它和 addIfUnderCorePoolSize 方法的實現基本一模一樣，只是 if 語句判斷條件中的 poolSize < maximumPoolSize 不同而已。

到這裡，大部分朋友應該對任務提交給執行緒池之後到被執行的整個過程有了一個基本的瞭解，下面總結一下

1）首先，要清楚 corePoolSize 和 maximumPoolSize 的含義；

2）其次，要知道 Worker 是用來起到什麼作用的；

3）要知道任務提交給執行緒池之後的處理策略，這裡總結一下主要有 4 點：

3.1)如果當前執行緒池中的執行緒數目小於 corePoolSize，則每來一個任務，就會建立一個執行緒去執行這個任務；

3.2)如果當前執行緒池中的執行緒數目 >= corePoolSize，則每來一個任務，會嘗試將其新增到任務快取隊列當中，若新增成功，則該任務會等待空閒執行緒將其取出去執行；

若新增失敗（一般來說是任務快取佇列已滿），則會嘗試建立新的執行緒去執行這個任務；

3.3)如果當前執行緒池中的執行緒數目達到 maximumPoolSize，則會採取任務拒絕策略進行處理；

3.4)如果執行緒池中的執行緒數量大於 corePoolSize 時，如果某執行緒空閒時間超過 keepAliveTime，執行緒將被終止，直至執行緒池中的執行緒數目不大於 corePoolSize ；

3.5)如果允許為核心池中的執行緒設定存活時間，那麼核心池中的執行緒空閒時間超過 keepAliveTime ，執行緒也會被終止。

執行緒池中的執行緒初始化

預設情況下，建立執行緒池之後，執行緒池中是沒有執行緒的，需要提交任務之後才會建立執行緒。

在實際中如果需要執行緒池建立之後立即建立執行緒，可以通過以下兩個方法辦到：

• prestartCoreThread()：初始化一個核心執行緒；

• prestartAllCoreThreads()：初始化所有核心執行緒

下面是這2個方法的實現：

 public boolean prestartCoreThread() {
 return addIfUnderCorePoolSize(null); //注意傳進去的引數是null
 }
 
 public int prestartAllCoreThreads() {
 int n = 0;
 while (addIfUnderCorePoolSize(null))//注意傳進去的引數是null
 ++n;
 return n;
 }

注意上面傳進去的引數是 null，根據第 2 小節的分析可知如果傳進去的引數為 null，則最後執行執行緒會阻塞在getTask方法中的

r = workQueue.take();

即等待任務佇列中有任務。

任務快取佇列及排隊策略

在前面我們多次提到了任務快取佇列，即 workQueue，它用來存放等待執行的任務。

workQueue 的型別為 BlockingQueue<Runnable>，通常可以取下面三種類型：

1）ArrayBlockingQueue：基於陣列的先進先出佇列，此佇列建立時必須指定大小；

2）LinkedBlockingQueue：基於連結串列的先進先出佇列，如果建立時沒有指定此佇列大小，則預設為Integer.MAX_VALUE；

3）synchronousQueue：這個佇列比較特殊，它不會儲存提交的任務，而是將直接新建一個執行緒來執行新來的任務。

任務拒絕策略

當執行緒池的任務快取佇列已滿並且執行緒池中的執行緒數目達到 maximumPoolSize，如果還有任務到來就會採取任務拒絕策略，通常有以下四種策略：

ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException異常。
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不丟擲異常。
ThreadPoolExecutor.DiscardOldestPolicy：丟棄佇列最前面的任務，然後重新嘗試執行任務（重複此過程）
ThreadPoolExecutor.CallerRunsPolicy：由呼叫執行緒處理該任務

執行緒池的關閉

ThreadPoolExecutor 提供了兩個方法，用於執行緒池的關閉，分別是 shutdown() 和 shutdownNow()，其中：

• shutdown()：不會立即終止執行緒池，而是要等所有任務快取佇列中的任務都執行完後才終止，但再也不會接受新的任務

• shutdownNow()：立即終止執行緒池，並嘗試打斷正在執行的任務，並且清空任務快取佇列，返回尚未執行的任務

執行緒池容量的動態調整

ThreadPoolExecutor 提供了動態調整執行緒池容量大小的方法：setCorePoolSize() 和 setMaximumPoolSize()，

• setCorePoolSize：設定核心池大小

• setMaximumPoolSize：設定執行緒池最大能建立的執行緒數目大小

當上述引數從小變大時，ThreadPoolExecutor 進行執行緒賦值，還可能立即建立新的執行緒來執行任務。

使用示例

前面我們討論了關於執行緒池的實現原理，這一節我們來看一下它的具體使用：

 public class Test {
 public static void main(String[] args) { 
 ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
 new ArrayBlockingQueue<Runnable>(5));
 
 for(int i=0;i<15;i++){
 MyTask myTask = new MyTask(i);
 executor.execute(myTask);
 System.out.println("執行緒池中執行緒數目："+executor.getPoolSize()+"，佇列中等待執行的任務數目："+
 executor.getQueue().size()+"，已執行玩別的任務數目："+executor.getCompletedTaskCount());
 }
 executor.shutdown();
 }
 }
 
 
 class MyTask implements Runnable {
 private int taskNum;
 
 public MyTask(int num) {
 this.taskNum = num;
 }
 
 @Override
 public void run() {
 System.out.println("正在執行task "+taskNum);
 try {
 Thread.currentThread().sleep(4000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("task "+taskNum+"執行完畢");
 }
 }

執行結果：

 正在執行task 0
 執行緒池中執行緒數目：1，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
 執行緒池中執行緒數目：2，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
 正在執行task 1
 執行緒池中執行緒數目：3，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
 正在執行task 2
 執行緒池中執行緒數目：4，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
 正在執行task 3
 執行緒池中執行緒數目：5，佇列中等待執行的任務數目：0，已執行玩別的任務數目：0
 正在執行task 4
 執行緒池中執行緒數目：5，佇列中等待執行的任務數目：1，已執行玩別的任務數目：0
 執行緒池中執行緒數目：5，佇列中等待執行的任務數目：2，已執行玩別的任務數目：0
 執行緒池中執行緒數目：5，佇列中等待執行的任務數目：3，已執行玩別的任務數目：0
 執行緒池中執行緒數目：5，佇列中等待執行的任務數目：4，已執行玩別的任務數目：0
 執行緒池中執行緒數目：5，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
 執行緒池中執行緒數目：6，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
 正在執行task 10
 執行緒池中執行緒數目：7，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
 正在執行task 11
 執行緒池中執行緒數目：8，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
 正在執行task 12
 執行緒池中執行緒數目：9，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
 正在執行task 13
 執行緒池中執行緒數目：10，佇列中等待執行的任務數目：5，已執行玩別的任務數目：0
 正在執行task 14
 task 3執行完畢
 task 0執行完畢
 task 2執行完畢
 task 1執行完畢
 正在執行task 8
 正在執行task 7
 正在執行task 6
 正在執行task 5
 task 4執行完畢
 task 10執行完畢
 task 11執行完畢
 task 13執行完畢
 task 12執行完畢
 正在執行task 9
 task 14執行完畢
 task 8執行完畢
 task 5執行完畢
 task 7執行完畢
 task 6執行完畢
 task 9執行完畢

從執行結果可以看出，當執行緒池中執行緒的數目大於 5 時，便將任務放入任務快取佇列裡面，當任務快取佇列滿了之後，便建立新的執行緒。

如果上面程式中，將 for 迴圈中改成執行 20 個任務，就會丟擲任務拒絕異常了。

不過在 java doc中，並不提倡我們直接使用 ThreadPoolExecutor，而是使用 Executors 類中提供的幾個靜態方法來建立執行緒池：

Executors.newCachedThreadPool(); //建立一個緩衝池，緩衝池容量大小為Integer.MAX_VALUE
Executors.newSingleThreadExecutor(); //建立容量為1的緩衝池
Executors.newFixedThreadPool(int); //建立固定容量大小的緩衝池

下面是這三個靜態方法的具體實現;

 public static ExecutorService newFixedThreadPool(int nThreads) {
 return new ThreadPoolExecutor(nThreads, nThreads,
 0L, TimeUnit.MILLISECONDS,
 new LinkedBlockingQueue<Runnable>());
 }
 public static ExecutorService newSingleThreadExecutor() {
 return new FinalizableDelegatedExecutorService
 (new ThreadPoolExecutor(1, 1,
 0L, TimeUnit.MILLISECONDS,
 new LinkedBlockingQueue<Runnable>()));
 }
 public static ExecutorService newCachedThreadPool() {
 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
 60L, TimeUnit.SECONDS,
 new SynchronousQueue<Runnable>());
 }

從它們的具體實現來看，它們實際上也是呼叫了 ThreadPoolExecutor，只不過引數都已配置好了。

newFixedThreadPoo l建立的執行緒池 corePoolSize 和 maximumPoolSize 值是相等的，它使用的LinkedBlockingQueue；

newSingleThreadExecutor 將 corePoolSize 和 maximumPoolSize 都設定為1，也使用的 LinkedBlockingQueue；

newCachedThreadPool 將 corePoolSize 設定為0，將 maximumPoolSize 設定為 Integer.MAX_VALUE，使用的SynchronousQueue，也就是說來了任務就建立執行緒執行，當執行緒空閒超過60秒，就銷燬執行緒。

實際中，如果 Executors 提供的三個靜態方法能滿足要求，就儘量使用它提供的三個方法，因為自己去手動配置ThreadPoolExecutor 的引數有點麻煩，要根據實際任務的型別和數量來進行配置。

另外，如果 ThreadPoolExecutor 達不到要求，可以自己繼承 ThreadPoolExecutor 類進行重寫。

如何合理配置執行緒池的大小

本節來討論一個比較重要的話題：如何合理配置執行緒池大小，僅供參考。

一般需要根據任務的型別來配置執行緒池大小：

如果是 CPU 密集型任務，就需要儘量壓榨 CPU，參考值可以設為 NCPU+1

如果是 IO 密集型任務，參考值可以設定為2*NCPU

當然，這只是一個參考值，具體的設定還需要根據實際情況進行調整，比如可以先將執行緒池大小設定為參考值，再觀察任務執行情況和系統負載、資源利用率來進行適當調整