（手機橫屏看原始碼更方便）

---

注：java原始碼分析部分如無特殊說明均基於 java8 版本。

注：執行緒池原始碼部分如無特殊說明均指ThreadPoolExecutor類。

簡介

上一章我們一起重溫了下執行緒的生命週期（六種狀態還記得不？），但是你知不知道其實執行緒池也是有生命週期的呢？！

問題

（1）執行緒池的狀態有哪些？

（2）各種狀態下對於任務佇列中的任務有何影響？

先上原始碼

其實，在我們講執行緒池體系結構的時候，講了一些方法，比如shutDown()/shutDownNow()，它們都是與執行緒池的生命週期相關聯的。

我們先來看一下執行緒池ThreadPoolExecutor中定義的生命週期中的狀態及相關方法：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3; // =29
private static final int CAPACITY   = (1 << COUNT_BITS) - 1; // =000 11111...

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS; // 111 00000...
private static final int SHUTDOWN   =  0 << COUNT_BITS; // 000 00000...
private static final int STOP       =  1 << COUNT_BITS; // 001 00000...
private static final int TIDYING    =  2 << COUNT_BITS; // 010 00000...
private static final int TERMINATED =  3 << COUNT_BITS; // 011 00000...

// 執行緒池的狀態
private static int runStateOf(int c)     { return c & ~CAPACITY; }
// 執行緒池中工作執行緒的數量
private static int workerCountOf(int c)  { return c & CAPACITY; }
// 計算ctl的值，等於執行狀態“加上”執行緒數量
private static int ctlOf(int rs, int wc) { return rs | wc; }
 

從上面這段程式碼，我們可以得出：

（1）執行緒池的狀態和工作執行緒的數量共同儲存在控制變數ctl中，類似於AQS中的state變數，不過這裡是直接使用的AtomicInteger，這裡換成unsafe+volatile也是可以的；

（2）ctl的高三位儲存執行狀態，低29位儲存工作執行緒的數量，也就是說執行緒的數量最多隻能有(2^29-1)個，也就是上面的CAPACITY；

（3）執行緒池的狀態一共有五種，分別是RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED；

（4）RUNNING，表示可接受新任務，且可執行佇列中的任務；

（5）SHUTDOWN，表示不接受新任務，但可執行佇列中的任務；

（6）STOP，表示不接受新任務，且不再執行佇列中的任務，且中斷正在執行的任務；

（7）TIDYING，所有任務已經中止，且工作執行緒數量為0，最後變遷到這個狀態的執行緒將要執行terminated()鉤子方法，只會有一個執行緒執行這個方法；

（8）TERMINATED，中止狀態，已經執行完terminated()鉤子方法；

流程圖

下面我們再來看看這些狀態之間是怎麼流轉的：

（1）新建執行緒池時，它的初始狀態為RUNNING，這個在上面定義ctl的時候可以看到；

（2）RUNNING->SHUTDOWN，執行shutdown()方法時；

（3）RUNNING->STOP，執行shutdownNow()方法時；

（4）SHUTDOWN->STOP，執行shutdownNow()方法時【本文由公從號“彤哥讀原始碼”原創】；

（5）STOP->TIDYING，執行了shutdown()或者shutdownNow()後，所有任務已中止，且工作執行緒數量為0時，此時會執行terminated()方法；

（6）TIDYING->TERMINATED，執行完terminated()方法後；

原始碼分析

你以為貼個狀態的原始碼，畫個圖就結束了嘛？那肯定不能啊，下面讓我們一起來看看原始碼中是怎麼控制的。

（1）RUNNING

RUNNING，比較簡單，建立執行緒池的時候就會初始化ctl，而ctl初始化為RUNNING狀態，所以執行緒池的初始狀態就為RUNNING狀態。

// 初始狀態為RUNNING
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

（2）SHUTDOWN

執行shutdown()方法時把狀態修改為SHUTDOWN，這裡肯定會成功，因為advanceRunState()方法中是個自旋，不成功不會退出。

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改狀態為SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 標記空閒執行緒為中斷狀態
        interruptIdleWorkers();
        onShutdown();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}
private void advanceRunState(int targetState) {
    for (;;) {
        int c = ctl.get();
        // 如果狀態大於SHUTDOWN，或者修改為SHUTDOWN成功了，才會break跳出自旋
        if (runStateAtLeast(c, targetState) ||
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

（3）STOP

執行shutdownNow()方法時，會把執行緒池狀態修改為STOP狀態，同時標記所有執行緒為中斷狀態。

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 修改為STOP狀態
        advanceRunState(STOP);
        // 標記所有執行緒為中斷狀態
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        // 【本文由公從號“彤哥讀原始碼”原創】
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

至於執行緒是否響應中斷其實是在佇列的take()或poll()方法中響應的，最後會到AQS中，它們檢測到執行緒中斷了會丟擲一個InterruptedException異常，然後getTask()中捕獲這個異常，並且在下一次的自旋時退出當前執行緒並減少工作執行緒的數量。

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 如果狀態為STOP了，這裡會直接退出迴圈，且減少工作執行緒數量
        // 退出迴圈了也就相當於這個執行緒的生命週期結束了
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            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 {
            // 真正響應中斷是在poll()方法或者take()方法中
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            // 這裡捕獲中斷異常
            timedOut = false;
        }
    }
}

這裡有一個問題，就是已經通過getTask()取出來且返回的任務怎麼辦？

實際上它們會正常執行完畢，有興趣的同學可以自己看看runWorker()這個方法，我們下一節會分析這個方法。

（4）TIDYING

當執行shutdown()或shutdownNow()之後，如果所有任務已中止，且工作執行緒數量為0，就會進入這個狀態。

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        // 下面幾種情況不會執行後續程式碼
        // 1. 執行中
        // 2. 狀態的值比TIDYING還大，也就是TERMINATED
        // 3. SHUTDOWN狀態且任務佇列不為空
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        // 工作執行緒數量不為0，也不會執行後續程式碼
        if (workerCountOf(c) != 0) {
            // 嘗試中斷空閒的執行緒
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // CAS修改狀態為TIDYING狀態
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    // 更新成功，執行terminated鉤子方法
                    terminated();
                } finally {
                    // 強制更新狀態為TERMINATED，這裡不需要CAS了
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

實際更新狀態為TIDYING和TERMINATED狀態的程式碼都在tryTerminate()方法中，實際上tryTerminated()方法在很多地方都有呼叫，比如shutdown()、shutdownNow()、執行緒退出時，所以說幾乎每個執行緒最後消亡的時候都會呼叫tryTerminate()方法，但最後只會有一個執行緒真正執行到修改狀態為TIDYING的地方。

修改狀態為TIDYING後執行terminated()方法，最後修改狀態為TERMINATED，標誌著執行緒池真正消亡了。

（5）TERMINATED

見TIDYING中分析。

彩蛋

本章我們一起從狀態定義、流程圖、原始碼分析等多個角度一起學習了執行緒池的生命週期，你掌握的怎麼樣呢？

下一章我們將開始學習執行緒池執行任務的主流程，對這一塊內容感到恐懼的同學可以先看看彤哥之前寫的“手寫執行緒池”的兩篇文章，對接下來學習執行緒池的主要流程非常有好處。

---

歡迎關注我的公眾號“彤哥讀原始碼”，檢視更多原始碼系列文章, 與彤哥一起暢遊原始碼的海洋。

相關推薦