Java多線程（十九）： J.U.C 之線程池：ThreadPoolExecutor

作爲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併發編程的藝術》）：

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一樣。

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和內存資源，所以在使用該線程池是，一定要注意控制併發的任務數，否則創建大量的線程可能導致嚴重的性能問題。

轉存失敗重新上傳取消

任務提交

線程池根據業務不同的需求提供了兩種方式提交任務：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；
1. rs >= SHUTDOWN ，表示當前線程處於SHUTDOWN ，STOP、TIDYING、TERMINATED狀態
2. rs == SHUTDOWN , firstTask != null時不允許添加線程，因爲線程處於SHUTDOWN 狀態，不允許添加任務
3. 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;
}

Java多線程（十九）： J.U.C 之線程池：ThreadPoolExecutor

內部狀態

創建線程池

線程池

任務提交

線程終止

Java多線程（十二）：J.U.C 之 Condition

使用kryo做序列化遇到的幾個坑

IO（二）：select、poll、epoll

Java多線程（十九）： J.U.C 之線程池：ThreadPoolExecutor

Websocket（三）：Socket.io

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結