原文出處http://cmsblogs.com/ 『chenssy』
作為Executor框架中最核心的類，ThreadPoolExecutor代表著鼎鼎大名的線程池，它給了我們足夠的理由來弄清楚它。
下面我們就通過源碼來一步一步弄清楚它。
內部狀態
線程有五種狀態：新建，就緒，運行，阻塞，死亡，線程池同樣有五種狀態：Running, SHUTDOWN, STOP, TIDYING, TERMINATED。
? ? 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定義為AtomicInteger ，其功能非常強大，記錄了“線程池中的任務數量”和“線程池的狀態”兩個信息。共32位，其中高3位表示"線程池狀態"，低29位表示"線程池中的任務數量"。
RUNNING? ? ? ? ? ? -- 對應的高3位值是111。
SHUTDOWN? ? ? -- 對應的高3位值是000。
STOP? ? ? ? ? ? ? ? ? -- 對應的高3位值是001。
TIDYING? ? ? ? ? ? ? -- 對應的高3位值是010。
TERMINATED? ? -- 對應的高3位值是011。
RUNNING：處于RUNNING狀態的線程池能夠接受新任務，以及對新添加的任務進行處理。
SHUTDOWN：處于SHUTDOWN狀態的線程池不可以接受新任務，但是可以對已添加的任務進行處理。
STOP：處于STOP狀態的線程池不接收新任務，不處理已添加的任務，并且會中斷正在處理的任務。
TIDYING：當所有的任務已終止，ctl記錄的"任務數量"為0，線程池會變為TIDYING狀態。當線程池變為TIDYING狀態時，會執行鉤子函數terminated()。terminated()在ThreadPoolExecutor類中是空的，若用戶想在線程池變為TIDYING時，進行相應的處理；可以通過重載terminated()函數來實現。
TERMINATED：線程池徹底終止的狀態。
各個狀態的轉換如下：
線程池狀態轉換
創建線程池
我們可以通過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.corePoolSize = corePoolSize;
? ? ? ? this.maximumPoolSize = maximumPoolSize;
? ? ? ? this.workQueue = workQueue;
? ? ? ? this.keepAliveTime = unit.toNanos(keepAliveTime);
? ? ? ? this.threadFactory = threadFactory;
? ? ? ? this.handler = handler;
? ? }
共有七個參數，每個參數含義如下：
corePoolSize
線程池中核心線程的數量。當提交一個任務時，線程池會新建一個線程來執行任務，直到當前線程數等于corePoolSize。如果調用了線程池的prestartAllCoreThreads()方法，線程池會提前創建并啟動所有基本線程。
maximumPoolSize
線程池中允許的最大線程數。線程池的阻塞隊列滿了之后，如果還有任務提交，如果當前的線程數小于maximumPoolSize，則會新建線程來執行任務。注意，如果使用的是無界隊列，該參數也就沒有什么效果了。
keepAliveTime
線程空閑的時間。線程的創建和銷毀是需要代價的。線程執行完任務后不會立即銷毀，而是繼續存活一段時間：keepAliveTime。默認情況下，該參數只有在線程數大于corePoolSize時才會生效。
unit
keepAliveTime的單位。TimeUnit
workQueue
用來保存等待執行的任務的阻塞隊列，等待的任務必須實現Runnable接口。我們可以選擇如下幾種：
ArrayBlockingQueue：基于數組結構的有界阻塞隊列，FIFO。【死磕Java并發】----J.U.C之阻塞隊列：ArrayBlockingQueue
LinkedBlockingQueue：基于鏈表結構的有界阻塞隊列，FIFO。
SynchronousQueue：不存儲元素的阻塞隊列，每個插入操作都必須等待一個移出操作，反之亦然。【死磕Java并發】----J.U.C之阻塞隊列：SynchronousQueue
PriorityBlockingQueue：具有優先界別的阻塞隊列。【死磕Java并發】----J.U.C之阻塞隊列：PriorityBlockingQueue
threadFactory
用于設置創建線程的工廠。該對象可以通過Executors.defaultThreadFactory()，如下：
? ? public static ThreadFactory defaultThreadFactory() {
? ? ? ? return new DefaultThreadFactory();
? ? }
返回的是DefaultThreadFactory對象，源碼如下：
? ? static class DefaultThreadFactory implements ThreadFactory {
? ? ? ? private static final AtomicInteger poolNumber = new AtomicInteger(1);
? ? ? ? private final ThreadGroup group;
? ? ? ? private final AtomicInteger threadNumber = new AtomicInteger(1);
? ? ? ? private final String namePrefix;
? ? ? ? DefaultThreadFactory() {
? ? ? ? ? ? SecurityManager s = System.getSecurityManager();
? ? ? ? ? ? group = (s != null) ? s.getThreadGroup() :
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? Thread.currentThread().getThreadGroup();
? ? ? ? ? ? namePrefix = "pool-" +
? ? ? ? ? ? ? ? ? ? ? ? ? poolNumber.getAndIncrement() +
? ? ? ? ? ? ? ? ? ? ? ? "-thread-";
? ? ? ? }
? ? ? ? public Thread newThread(Runnable r) {
? ? ? ? ? ? Thread t = new Thread(group, r,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? namePrefix + threadNumber.getAndIncrement(),
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 0);
? ? ? ? ? ? if (t.isDaemon())
? ? ? ? ? ? ? ? t.setDaemon(false);
? ? ? ? ? ? if (t.getPriority() != Thread.NORM_PRIORITY)
? ? ? ? ? ? ? ? t.setPriority(Thread.NORM_PRIORITY);
? ? ? ? ? ? return t;
? ? ? ? }
? ? }
ThreadFactory的左右就是提供創建線程的功能的線程工廠。他是通過newThread()方法提供創建線程的功能，newThread()方法創建的線程都是“非守護線程”而且“線程優先級都是Thread.NORM_PRIORITY”。
handler
RejectedExecutionHandler，線程池的拒絕策略。所謂拒絕策略，是指將任務添加到線程池中時，線程池拒絕該任務所采取的相應策略。當向線程池中提交任務時，如果此時線程池中的線程已經飽和了，而且阻塞隊列也已經滿了，則線程池會選擇一種拒絕策略來處理該任務。
線程池提供了四種拒絕策略：
AbortPolicy：直接拋出異常，默認策略；
CallerRunsPolicy：用調用者所在的線程來執行任務；
DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，并執行當前任務；
DiscardPolicy：直接丟棄任務；
當然我們也可以實現自己的拒絕策略，例如記錄日志等等，實現RejectedExecutionHandler接口即可。
線程池
Executor框架提供了三種線程池，他們都可以通過工具類Executors來創建。
FixedThreadPool
FixedThreadPool，可重用固定線程數的線程池，其定義如下：
? ? public static ExecutorService newFixedThreadPool(int nThreads) {
? ? ? ? return new ThreadPoolExecutor(nThreads, nThreads,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 0L, TimeUnit.MILLISECONDS,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new LinkedBlockingQueue<Runnable>());
? ? }
corePoolSize 和 maximumPoolSize都設置為創建FixedThreadPool時指定的參數nThreads，意味著當線程池滿時且阻塞隊列也已經滿時，如果繼續提交任務，則會直接走拒絕策略，該線程池不會再新建線程來執行任務，而是直接走拒絕策略。FixedThreadPool使用的是默認的拒絕策略，即AbortPolicy，則直接拋出異常。
keepAliveTime設置為0L，表示空閑的線程會立刻終止。
workQueue則是使用LinkedBlockingQueue，但是沒有設置范圍，那么則是最大值（Integer.MAX_VALUE），這基本就相當于一個無界隊列了。使用該“無界隊列”則會帶來哪些影響呢？當線程池中的線程數量等于corePoolSize 時，如果繼續提交任務，該任務會被添加到阻塞隊列workQueue中，當阻塞隊列也滿了之后，則線程池會新建線程執行任務直到maximumPoolSize。由于FixedThreadPool使用的是“無界隊列”LinkedBlockingQueue，那么maximumPoolSize參數無效，同時指定的拒絕策略AbortPolicy也將無效。而且該線程池也不會拒絕提交的任務，如果客戶端提交任務的速度快于任務的執行，那么keepAliveTime也是一個無效參數。
其運行圖如下（參考《Java并發編程的藝術》）：
FixedThreadPool
SingleThreadExecutor
SingleThreadExecutor是使用單個worker線程的Executor，定義如下：
? ? public static ExecutorService newSingleThreadExecutor() {
? ? ? ? return new FinalizableDelegatedExecutorService
? ? ? ? ? ? (new ThreadPoolExecutor(1, 1,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 0L, TimeUnit.MILLISECONDS,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new LinkedBlockingQueue<Runnable>()));
? ? }
作為單一worker線程的線程池，SingleThreadExecutor把corePool和maximumPoolSize均被設置為1，和FixedThreadPool一樣使用的是無界隊列LinkedBlockingQueue,所以帶來的影響和FixedThreadPool一樣。
SingleThreadExecutor
CachedThreadPool
CachedThreadPool是一個會根據需要創建新線程的線程池 ，他定義如下：
? ? public static ExecutorService newCachedThreadPool() {
? ? ? ? return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 60L, TimeUnit.SECONDS,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new SynchronousQueue<Runnable>());
? ? }
CachedThreadPool的corePool為0，maximumPoolSize為Integer.MAX_VALUE，這就意味著所有的任務一提交就會加入到阻塞隊列中。keepAliveTime這是為60L，unit設置為TimeUnit.SECONDS，意味著空閑線程等待新任務的最長時間為60秒，空閑線程超過60秒后將會被終止。阻塞隊列采用的SynchronousQueue，而我們在【死磕Java并發】----J.U.C之阻塞隊列：SynchronousQueue中了解到SynchronousQueue是一個沒有元素的阻塞隊列，加上corePool = 0 ，maximumPoolSize = Integer.MAX_VALUE，這樣就會存在一個問題，如果主線程提交任務的速度遠遠大于CachedThreadPool的處理速度，則CachedThreadPool會不斷地創建新線程來執行任務，這樣有可能會導致系統耗盡CPU和內存資源，所以在使用該線程池是，一定要注意控制并發的任務數，否則創建大量的線程可能導致嚴重的性能問題。
CachedThreadPool
任務提交
線程池根據業務不同的需求提供了兩種方式提交任務：Executor.execute()、ExecutorService.submit()。其中ExecutorService.submit()可以獲取該任務執行的Future。
我們以Executor.execute()為例，來看看線程池的任務提交經歷了那些過程。
定義：
public interface Executor {
? ? void execute(Runnable command);
}
ThreadPoolExecutor提供實現：
? ? public void execute(Runnable command) {
? ? ? ? if (command == null)
? ? ? ? ? ? throw new NullPointerException();
? ? ? ? int c = ctl.get();
? ? ? ? if (workerCountOf(c) < corePoolSize) {
? ? ? ? ? ? if (addWorker(command, true))
? ? ? ? ? ? ? ? return;
? ? ? ? ? ? c = ctl.get();
? ? ? ? }
? ? ? ? if (isRunning(c) && workQueue.offer(command)) {
? ? ? ? ? ? int recheck = ctl.get();
? ? ? ? ? ? if (! isRunning(recheck) && remove(command))
? ? ? ? ? ? ? ? reject(command);
? ? ? ? ? ? else if (workerCountOf(recheck) == 0)
? ? ? ? ? ? ? ? addWorker(null, false);
? ? ? ? }
? ? ? ? else if (!addWorker(command, false))
? ? ? ? ? ? reject(command);
? ? }
執行流程如下：
如果線程池當前線程數小于corePoolSize，則調用addWorker創建新線程執行任務，成功返回true，失敗執行步驟2。
如果線程池處于RUNNING狀態，則嘗試加入阻塞隊列，如果加入阻塞隊列成功，則嘗試進行Double Check，如果加入失敗，則執行步驟3。
如果線程池不是RUNNING狀態或者加入阻塞隊列失敗，則嘗試創建新線程直到maxPoolSize，如果失敗，則調用reject()方法運行相應的拒絕策略。
在步驟2中如果加入阻塞隊列成功了，則會進行一個Double Check的過程。Double Check過程的主要目的是判斷加入到阻塞隊里中的線程是否可以被執行。如果線程池不是RUNNING狀態，則調用remove()方法從阻塞隊列中刪除該任務，然后調用reject()方法處理任務。否則需要確保還有線程執行。
addWorker
當線程中的當前線程數小于corePoolSize，則調用addWorker()創建新線程執行任務，當前線程數則是根據ctl變量來獲取的，調用workerCountOf(ctl)獲取低29位即可：
? ? private static int workerCountOf(int c)? { return c & CAPACITY; }
addWorker(Runnable firstTask, boolean core)方法用于創建線程執行任務，源碼如下：
? ? private boolean addWorker(Runnable firstTask, boolean core) {
? ? ? ? retry:
? ? ? ? for (;;) {
? ? ? ? ? ? int c = ctl.get();
? ? ? ? ? ? // 獲取當前線程狀態
? ? ? ? ? ? int rs = runStateOf(c);
? ? ? ? ? ? if (rs >= SHUTDOWN &&
? ? ? ? ? ? ? ? ? ? ! (rs == SHUTDOWN &&
? ? ? ? ? ? ? ? ? ? ? ? ? ? firstTask == null &&
? ? ? ? ? ? ? ? ? ? ? ? ? ? ! workQueue.isEmpty()))
? ? ? ? ? ? ? ? return false;
? ? ? ? ? ? // 內層循環，worker + 1
? ? ? ? ? ? for (;;) {
? ? ? ? ? ? ? ? // 線程數量
? ? ? ? ? ? ? ? int wc = workerCountOf(c);
? ? ? ? ? ? ? ? // 如果當前線程數大于線程最大上限CAPACITY? return false
? ? ? ? ? ? ? ? // 若core == true，則與corePoolSize 比較，否則與maximumPoolSize ，大于 return false
? ? ? ? ? ? ? ? if (wc >= CAPACITY ||
? ? ? ? ? ? ? ? ? ? ? ? wc >= (core ? corePoolSize : maximumPoolSize))
? ? ? ? ? ? ? ? ? ? return false;
? ? ? ? ? ? ? ? // worker + 1,成功跳出retry循環
? ? ? ? ? ? ? ? if (compareAndIncrementWorkerCount(c))
? ? ? ? ? ? ? ? ? ? break retry;
? ? ? ? ? ? ? ? // CAS add worker 失敗，再次讀取ctl
? ? ? ? ? ? ? ? c = ctl.get();
? ? ? ? ? ? ? ? // 如果狀態不等于之前獲取的state，跳出內層循環，繼續去外層循環判斷
? ? ? ? ? ? ? ? if (runStateOf(c) != rs)
? ? ? ? ? ? ? ? ? ? continue retry;
? ? ? ? ? ? }
? ? ? ? }
? ? ? ? boolean workerStarted = false;
? ? ? ? boolean workerAdded = false;
? ? ? ? Worker w = null;
? ? ? ? try {
? ? ? ? ? ? // 新建線程：Worker
? ? ? ? ? ? w = new Worker(firstTask);
? ? ? ? ? ? // 當前線程
? ? ? ? ? ? final Thread t = w.thread;
? ? ? ? ? ? if (t != null) {
? ? ? ? ? ? ? ? // 獲取主鎖：mainLock
? ? ? ? ? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? ? ? ? ? mainLock.lock();
? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? // 線程狀態
? ? ? ? ? ? ? ? ? ? int rs = runStateOf(ctl.get());
? ? ? ? ? ? ? ? ? ? // rs < SHUTDOWN ==> 線程處于RUNNING狀態
? ? ? ? ? ? ? ? ? ? // 或者線程處于SHUTDOWN狀態，且firstTask == null（可能是workQueue中仍有未執行完成的任務，創建沒有初始任務的worker線程執行）
? ? ? ? ? ? ? ? ? ? if (rs < SHUTDOWN ||
? ? ? ? ? ? ? ? ? ? ? ? ? ? (rs == SHUTDOWN && firstTask == null)) {
? ? ? ? ? ? ? ? ? ? ? ? // 當前線程已經啟動，拋出異常
? ? ? ? ? ? ? ? ? ? ? ? if (t.isAlive()) // precheck that t is startable
? ? ? ? ? ? ? ? ? ? ? ? ? ? throw new IllegalThreadStateException();
? ? ? ? ? ? ? ? ? ? ? ? // workers是一個HashSet<Worker>
? ? ? ? ? ? ? ? ? ? ? ? workers.add(w);
? ? ? ? ? ? ? ? ? ? ? ? // 設置最大的池大小largestPoolSize，workerAdded設置為true
? ? ? ? ? ? ? ? ? ? ? ? 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;
? ? }
判斷當前線程是否可以添加任務，如果可以則進行下一步，否則return false；
rs >= SHUTDOWN ，表示當前線程處于SHUTDOWN ，STOP、TIDYING、TERMINATED狀態
rs == SHUTDOWN , firstTask != null時不允許添加線程，因為線程處于SHUTDOWN 狀態，不允許添加任務
rs == SHUTDOWN , firstTask == null，但workQueue.isEmpty() == true，不允許添加線程，因為firstTask == null是為了添加一個沒有任務的線程然后再從workQueue中獲取任務的，如果workQueue == null，則說明添加的任務沒有任何意義。
內嵌循環，通過CAS worker + 1
獲取主鎖mailLock，如果線程池處于RUNNING狀態獲取處于SHUTDOWN狀態且 firstTask == null，則將任務添加到workers Queue中，然后釋放主鎖mainLock，然后啟動線程，然后return true，如果中途失敗導致workerStarted= false，則調用addWorkerFailed()方法進行處理。
在這里需要好好理論addWorker中的參數，在execute()方法中，有三處調用了該方法：
第一次：workerCountOf(c) < corePoolSize ==> addWorker(command, true)，這個很好理解，當然線程池的線程數量小于 corePoolSize ，則新建線程執行任務即可，在執行過程core == true，內部與corePoolSize比較即可。
第二次：加入阻塞隊列進行Double Check時，else if (workerCountOf(recheck) == 0) ==>addWorker(null, false)。如果線程池中的線程==0，按照道理應該該任務應該新建線程執行任務，但是由于已經該任務已經添加到了阻塞隊列，那么就在線程池中新建一個空線程，然后從阻塞隊列中取線程即可。
第三次：線程池不是RUNNING狀態或者加入阻塞隊列失敗：else if (!addWorker(command, false))，這里core == fase，則意味著是與maximumPoolSize比較。
在新建線程執行任務時，將講Runnable包裝成一個Worker，Woker為ThreadPoolExecutor的內部類
Woker內部類
Woker的源碼如下：
? ? private final class Worker extends AbstractQueuedSynchronizer
? ? ? ? ? ? implements Runnable {
? ? ? ? private static final long serialVersionUID = 6138294804551838833L;
? ? ? ? // task 的thread
? ? ? ? final Thread thread;
? ? ? ? // 運行的任務task
? ? ? ? Runnable firstTask;
? ? ? ? volatile long completedTasks;
? ? ? ? Worker(Runnable firstTask) {
? ? ? ? ? ? //設置AQS的同步狀態private volatile int state，是一個計數器，大于0代表鎖已經被獲取
? ? ? ? ? ? setState(-1);
? ? ? ? ? ? this.firstTask = firstTask;
? ? ? ? ? ? // 利用ThreadFactory和 Worker這個Runnable創建的線程對象
? ? ? ? ? ? this.thread = getThreadFactory().newThread(this);
? ? ? ? }
? ? ? ? // 任務執行
? ? ? ? public void run() {
? ? ? ? ? ? runWorker(this);
? ? ? ? }
? ? }
從Worker的源碼中我們可以看到Woker繼承AQS，實現Runnable接口，所以可以認為Worker既是一個可以執行的任務，也可以達到獲取鎖釋放鎖的效果。這里繼承AQS主要是為了方便線程的中斷處理。這里注意兩個地方：構造函數、run()。構造函數主要是做三件事：1.設置同步狀態state為-1，同步狀態大于0表示就已經獲取了鎖，2.設置將當前任務task設置為firstTask，3.利用Worker本身對象this和ThreadFactory創建線程對象。
當線程thread啟動（調用start()方法）時，其實就是執行Worker的run()方法，內部調用runWorker()。
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 {
? ? ? ? ? ? while (task != null || (task = getTask()) != null) {
? ? ? ? ? ? ? ? // worker 獲取鎖
? ? ? ? ? ? ? ? w.lock();
? ? ? ? ? ? ? ? // 確保只有當線程是stoping時，才會被設置為中斷，否則清楚中斷標示
? ? ? ? ? ? ? ? // 如果線程池狀態 >= STOP ,且當前線程沒有設置中斷狀態，則wt.interrupt()
? ? ? ? ? ? ? ? // 如果線程池狀態 < STOP，但是線程已經中斷了，再次判斷線程池是否 >= STOP，如果是 wt.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;
? ? ? ? ? ? ? ? ? ? // 完成任務數 + 1
? ? ? ? ? ? ? ? ? ? w.completedTasks++;
? ? ? ? ? ? ? ? ? ? // 釋放鎖
? ? ? ? ? ? ? ? ? ? w.unlock();
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }
? ? ? ? ? ? completedAbruptly = false;
? ? ? ? } finally {
? ? ? ? ? ? processWorkerExit(w, completedAbruptly);
? ? ? ? }
? ? }
運行流程
根據worker獲取要執行的任務task，然后調用unlock()方法釋放鎖，這里釋放鎖的主要目的在于中斷，因為在new Worker時，設置的state為-1，調用unlock()方法可以將state設置為0，這里主要原因就在于interruptWorkers()方法只有在state >= 0時才會執行；
通過getTask()獲取執行的任務，調用task.run()執行，當然在執行之前會調用worker.lock()上鎖，執行之后調用worker.unlock()放鎖；
在任務執行前后，可以根據業務場景自定義beforeExecute() 和 afterExecute()方法，則兩個方法在ThreadPoolExecutor中是空實現；
如果線程執行完成，則會調用getTask()方法從阻塞隊列中獲取新任務，如果阻塞隊列為空，則根據是否超時來判斷是否需要阻塞；
task == null或者拋出異常（beforeExecute()、task.run()、afterExecute()均有可能）導致worker線程終止，則調用processWorkerExit()方法處理worker退出流程。
getTask()
? ? private Runnable getTask() {
? ? ? ? boolean timedOut = false; // Did the last poll() time out?
? ? ? ? for (;;) {
? ? ? ? ? ? // 線程池狀態
? ? ? ? ? ? int c = ctl.get();
? ? ? ? ? ? int rs = runStateOf(c);
? ? ? ? ? ? // 線程池中狀態 >= STOP 或者 線程池狀態 == SHUTDOWN且阻塞隊列為空，則worker - 1，return null
? ? ? ? ? ? if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
? ? ? ? ? ? ? ? decrementWorkerCount();
? ? ? ? ? ? ? ? return null;
? ? ? ? ? ? }
? ? ? ? ? ? int wc = workerCountOf(c);
? ? ? ? ? ? // 判斷是否需要超時控制
? ? ? ? ? ? boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
? ? ? ? ? ? if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
? ? ? ? ? ? ? ? if (compareAndDecrementWorkerCount(c))
? ? ? ? ? ? ? ? ? ? return null;
? ? ? ? ? ? ? ? continue;
? ? ? ? ? ? }
? ? ? ? ? ? try {
? ? ? ? ? ? ? ? // 從阻塞隊列中獲取task
? ? ? ? ? ? ? ? // 如果需要超時控制，則調用poll()，否則調用take()
? ? ? ? ? ? ? ? Runnable r = timed ?
? ? ? ? ? ? ? ? ? ? ? ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
? ? ? ? ? ? ? ? ? ? ? ? workQueue.take();
? ? ? ? ? ? ? ? if (r != null)
? ? ? ? ? ? ? ? ? ? return r;
? ? ? ? ? ? ? ? timedOut = true;
? ? ? ? ? ? } catch (InterruptedException retry) {
? ? ? ? ? ? ? ? timedOut = false;
? ? ? ? ? ? }
? ? ? ? }
? ? }
timed == true，調用poll()方法，如果在keepAliveTime時間內還沒有獲取task的話，則返回null，繼續循環。timed == false，則調用take()方法，該方法為一個阻塞方法，沒有任務時會一直阻塞掛起，直到有任務加入時對該線程喚醒，返回任務。
在runWorker()方法中，無論最終結果如何，都會執行processWorkerExit()方法對worker進行退出處理。
processWorkerExit()
? ? private void processWorkerExit(Worker w, boolean completedAbruptly) {
? ? ? ? // true：用戶線程運行異常,需要扣減
? ? ? ? // false：getTask方法中扣減線程數量
? ? ? ? if (completedAbruptly)
? ? ? ? ? ? decrementWorkerCount();
? ? ? ? // 獲取主鎖
? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? mainLock.lock();
? ? ? ? try {
? ? ? ? ? ? completedTaskCount += w.completedTasks;
? ? ? ? ? ? // 從HashSet中移出worker
? ? ? ? ? ? workers.remove(w);
? ? ? ? } finally {
? ? ? ? ? ? mainLock.unlock();
? ? ? ? }
? ? ? ? // 有worker線程移除，可能是最后一個線程退出需要嘗試終止線程池
? ? ? ? tryTerminate();
? ? ? ? int c = ctl.get();
? ? ? ? // 如果線程為running或shutdown狀態，即tryTerminate()沒有成功終止線程池，則判斷是否有必要一個worker
? ? ? ? if (runStateLessThan(c, STOP)) {
? ? ? ? ? ? // 正常退出，計算min：需要維護的最小線程數量
? ? ? ? ? ? if (!completedAbruptly) {
? ? ? ? ? ? ? ? // allowCoreThreadTimeOut 默認false：是否需要維持核心線程的數量
? ? ? ? ? ? ? ? int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
? ? ? ? ? ? ? ? // 如果min ==0 或者workerQueue為空，min = 1
? ? ? ? ? ? ? ? if (min == 0 && ! workQueue.isEmpty())
? ? ? ? ? ? ? ? ? ? min = 1;
? ? ? ? ? ? ? ? // 如果線程數量大于最少數量min，直接返回，不需要新增線程
? ? ? ? ? ? ? ? if (workerCountOf(c) >= min)
? ? ? ? ? ? ? ? ? ? return; // replacement not needed
? ? ? ? ? ? }
? ? ? ? ? ? // 添加一個沒有firstTask的worker
? ? ? ? ? ? addWorker(null, false);
? ? ? ? }
? ? }
首先completedAbruptly的值來判斷是否需要對線程數-1處理，如果completedAbruptly == true，說明在任務運行過程中出現了異常，那么需要進行減1處理，否則不需要，因為減1處理在getTask()方法中處理了。然后從HashSet中移出該worker，過程需要獲取mainlock。然后調用tryTerminate()方法處理，該方法是對最后一個線程退出做終止線程池動作。如果線程池沒有終止，那么線程池需要保持一定數量的線程，則通過addWorker(null,false)新增一個空的線程。
addWorkerFailed()
在addWorker()方法中，如果線程t==null，或者在add過程出現異常，會導致workerStarted == false，那么在最后會調用addWorkerFailed()方法：
? ? private void addWorkerFailed(Worker w) {
? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? mainLock.lock();
? ? ? ? try {
? ? ? ? ? ? // 從HashSet中移除該worker
? ? ? ? ? ? if (w != null)
? ? ? ? ? ? ? ? workers.remove(w);
? ? ? ? ? ? // 線程數 - 1
? ? ? ? ? ? decrementWorkerCount();
? ? ? ? ? ? // 嘗試終止線程
? ? ? ? ? ? tryTerminate();
? ? ? ? } finally {
? ? ? ? ? ? mainLock.unlock();
? ? ? ? }
? ? }
整個邏輯顯得比較簡單。
tryTerminate()
當線程池涉及到要移除worker時候都會調用tryTerminate()，該方法主要用于判斷線程池中的線程是否已經全部移除了，如果是的話則關閉線程池。
? ? final void tryTerminate() {
? ? ? ? for (;;) {
? ? ? ? ? ? int c = ctl.get();
? ? ? ? ? ? // 線程池處于Running狀態
? ? ? ? ? ? // 線程池已經終止了
? ? ? ? ? ? // 線程池處于ShutDown狀態，但是阻塞隊列不為空
? ? ? ? ? ? if (isRunning(c) ||
? ? ? ? ? ? ? ? ? ? runStateAtLeast(c, TIDYING) ||
? ? ? ? ? ? ? ? ? ? (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
? ? ? ? ? ? ? ? return;
? ? ? ? ? ? // 執行到這里，就意味著線程池要么處于STOP狀態，要么處于SHUTDOWN且阻塞隊列為空
? ? ? ? ? ? // 這時如果線程池中還存在線程，則會嘗試中斷線程
? ? ? ? ? ? if (workerCountOf(c) != 0) {
? ? ? ? ? ? ? ? // /線程池還有線程，但是隊列沒有任務了，需要中斷喚醒等待任務的線程
? ? ? ? ? ? ? ? // （runwoker的時候首先就通過w.unlock設置線程可中斷，getTask最后面的catch處理中斷）
? ? ? ? ? ? ? ? interruptIdleWorkers(ONLY_ONE);
? ? ? ? ? ? ? ? return;
? ? ? ? ? ? }
? ? ? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? ? ? mainLock.lock();
? ? ? ? ? ? try {
? ? ? ? ? ? ? ? // 嘗試終止線程池
? ? ? ? ? ? ? ? if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
? ? ? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? ? ? terminated();
? ? ? ? ? ? ? ? ? ? } finally {
? ? ? ? ? ? ? ? ? ? ? ? // 線程池狀態轉為TERMINATED
? ? ? ? ? ? ? ? ? ? ? ? ctl.set(ctlOf(TERMINATED, 0));
? ? ? ? ? ? ? ? ? ? ? ? termination.signalAll();
? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? ? ? return;
? ? ? ? ? ? ? ? }
? ? ? ? ? ? } finally {
? ? ? ? ? ? ? ? mainLock.unlock();
? ? ? ? ? ? }
? ? ? ? }
? ? }
在關閉線程池的過程中，如果線程池處于STOP狀態或者處于SHUDOWN狀態且阻塞隊列為null，則線程池會調用interruptIdleWorkers()方法中斷所有線程，注意ONLY_ONE== true，表示僅中斷一個線程。
interruptIdleWorkers
? ? private void interruptIdleWorkers(boolean onlyOne) {
? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? mainLock.lock();
? ? ? ? try {
? ? ? ? ? ? for (Worker w : workers) {
? ? ? ? ? ? ? ? Thread t = w.thread;
? ? ? ? ? ? ? ? if (!t.isInterrupted() && w.tryLock()) {
? ? ? ? ? ? ? ? ? ? try {
? ? ? ? ? ? ? ? ? ? ? ? t.interrupt();
? ? ? ? ? ? ? ? ? ? } catch (SecurityException ignore) {
? ? ? ? ? ? ? ? ? ? } finally {
? ? ? ? ? ? ? ? ? ? ? ? w.unlock();
? ? ? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? }
? ? ? ? ? ? ? ? if (onlyOne)
? ? ? ? ? ? ? ? ? ? break;
? ? ? ? ? ? }
? ? ? ? } finally {
? ? ? ? ? ? mainLock.unlock();
? ? ? ? }
? ? }
onlyOne==true僅終止一個線程，否則終止所有線程。
線程終止
線程池ThreadPoolExecutor提供了shutdown()和shutDownNow()用于關閉線程池。
shutdown()：按過去執行已提交任務的順序發起一個有序的關閉，但是不接受新任務。
shutdownNow() :嘗試停止所有的活動執行任務、暫停等待任務的處理，并返回等待執行的任務列表。
shutdown
? ? public void shutdown() {
? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? mainLock.lock();
? ? ? ? try {
? ? ? ? ? ? checkShutdownAccess();
? ? ? ? ? ? // 推進線程狀態
? ? ? ? ? ? advanceRunState(SHUTDOWN);
? ? ? ? ? ? // 中斷空閑的線程
? ? ? ? ? ? interruptIdleWorkers();
? ? ? ? ? ? // 交給子類實現
? ? ? ? ? ? onShutdown();
? ? ? ? } finally {
? ? ? ? ? ? mainLock.unlock();
? ? ? ? }
? ? ? ? tryTerminate();
? ? }
shutdownNow
? ? 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會調用interruptWorkers()方法中斷所有線程。
? ? private void interruptWorkers() {
? ? ? ? final ReentrantLock mainLock = this.mainLock;
? ? ? ? mainLock.lock();
? ? ? ? try {
? ? ? ? ? ? for (Worker w : workers)
? ? ? ? ? ? ? ? w.interruptIfStarted();
? ? ? ? } finally {
? ? ? ? ? ? mainLock.unlock();
? ? ? ? }
? ? }
同時會調用drainQueue()方法返回等待執行到任務列表。
? ? private List<Runnable> drainQueue() {
? ? ? ? BlockingQueue<Runnable> q = workQueue;
? ? ? ? ArrayList<Runnable> taskList = new ArrayList<Runnable>();
? ? ? ? q.drainTo(taskList);
? ? ? ? if (!q.isEmpty()) {
? ? ? ? ? ? for (Runnable r : q.toArray(new Runnable[0])) {
? ? ? ? ? ? ? ? if (q.remove(r))
? ? ? ? ? ? ? ? ? ? taskList.add(r);
? ? ? ? ? ? }
? ? ? ? }
? ? ? ? return taskList;
? ? }
歡迎掃一掃我的公眾號關注 — 及時得到博客訂閱哦！
個人微信公眾號
