Java線程池是如何保證核心線程不被銷燬的

對於Java中 Thread 對象，同一個線程對象調用 start 方法後，會在執行完run 後走向終止（TERMINATED）狀態，也就是說一個線程對象是不可以通過多次調用 start 方法重複執行 run 方法內容的。

問題：那 Java 線程池中是如何保證核心線程不會終止的呢？

接下來將通過源碼分析線程池是如何保證核心線程不被終止的，在分析前需要了解 ThreadPoolExecutor中幾個重要成員變量和方法，便於下面源碼閱讀：

ThreadPoolExecutor 成員變量和方法介紹

ctl 原子整型變量

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

ctl 包含兩個字段
- workerCount：表示線程池中實際生效的線程數；
- runState：表示線程池運行狀態（注意和線程狀態進行區分），線程池狀態包括以下幾種：
  - RUNNING：可以接收新任務並可執行隊列中的任務；
  - SHUTDOWN：不接收新任務，但可執行隊列中的任務；
  - STOP：不接收新任務，不執行隊列任務並且中斷正在執行的任務；
  - TIDYING：所有任務已終止，workerCount 爲0，將會運行鉤子方法 terminated；
  - TERMINATED：terminated 方法調用完成的狀態。

線程池中實際生效線程的最大容量

//Integer.SIZE等於32
private static final int COUNT_BITS = Integer.SIZE - 3;
//實際有效線程的最大容量
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

實際生效最大線程數爲
$2^{29} - 1$
爲何使用int類型是因爲相對於long運行的更快一點，如果將來int不夠用，可以使用AtomicLong代替。

線程池運行狀態

// 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;

這裏我們僅需要知道只有運行（RUNNING）狀態是小於0的，其他狀態下都是大於等於0的。
4. 獲取線程池運行狀態

private static int runStateOf(int c)     { return c & ~CAPACITY; }

方法入參 c 即爲 ctl，通過該方法位運算可以得到線程池的狀態值，並與 3 中的狀態進行比較來進行邏輯處理。
5. 獲取線程池中當前實際有效的線程數量

private static int workerCountOf(int c)  { return c & CAPACITY; }

同上，方法入參 c 爲 ctl 原子整形變量，通過位運算得到線程池中實際的線程數 workCount。
6. 工作線程集合

private final HashSet<Worker> workers = new HashSet<Worker>();

線程池中每一個有效線程都會被包裝爲 Worker 對象。
7. Worker 內部類

private final class Worker extends AbstractQueuedSynchronizer implements Runnable

類 Worker 主要用於維護運行任務線程的中斷控制狀態；
繼承 AQS 實現了一個簡單的不可重入互斥鎖，而不是使用可重入鎖，因爲不希望工作任務在調用setCorePoolSize之類的池控制方法時能夠重新獲取鎖;
爲了在線程真正開始運行任務之前禁止中斷，將鎖狀態初始化爲負值，並在啓動時清除它（runWorker中）。

其他如 corePoolSize、maximumPoolSize、threadFactory、workQueue等就不做贅述了。

案例分析

該案例不執行 shutdown 方法，這樣可以保證線程池一直處於運行狀態(RUNNING)

public static void main(String[] args) {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2,
            0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(6),
            Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
    for (int i = 0; i < 8; i++) {
        int num = i;
        threadPoolExecutor.execute(() -> {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " - " + num);
            System.out.println(threadName + " 開始睡眠...");
            try {
                //暫緩線程執行
                TimeUnit.MILLISECONDS.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(threadName +" 結束睡眠...");
        });
    }

    //threadPoolExecutor.shutdown();
}

跟蹤 execute 方法源碼，查看核心線程是如何被加添到池中的：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    //獲取線程池控制狀態
    int c = ctl.get();
    //通過workerCountOf計算出實際線程數
    if (workerCountOf(c) < corePoolSize) {
        //未超過核心線程數，則新增 Worker 對象，true表示核心線程
        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，每添加新的任務（command），都會創建新的線程（Worker中創建），即使有空閒線程存在；
核心線程數等於corePoolSize後，如果繼續添加新的任務（command），會將任務添加到阻塞隊列 workQueue 中，等待調度；
如果添加到隊列失敗，則檢查 corePoolSize 是否小於 maximumPoolSize，如果小於則創建新的線程執行任務，直到線程總數等於 maximumPoolSize；
當線程數等於 maximumPoolSize 並且隊列已滿了，後續新增任務將會觸發線程飽和策略。

上面代碼中我們關心 addWorker 方法，它有兩個參數，第一個是 Runnable 對象，第二參數是標記是否核心線程，true爲核心線程，接下來看下源碼：

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        // 省略部分代碼
        ......
        
        for (;;) {
            //core主要用於判斷是否繼續創建新線程
            int wc = workerCountOf(c);
            //workCount 大於總容量或者workCount大於核心線程或最大線程將直接返回
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //通過CAS將c加1，也就是將workCount加1    
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
             retry inner loop
        }
    }

    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        //創建新線程
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            //省略部分代碼
            ......
            workers.add(w);
            int s = workers.size();
            if (s > largestPoolSize)
                largestPoolSize = s;
            workerAdded = true;
            ......
            
            if (workerAdded) {
                //啓動線程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

從 addWorker 方法中，可以看到從 Worker 對象中獲取到線程對象 t ，並調用 start 方法啓動線程，那這個 t 線程是如何來的呢？
擴展：java retry:詳解

接下來要看下 Worker 是如何創建線程的：

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    final Thread thread;
    /**初始執行任務，有可能爲空*/
    Runnable firstTask;
    
    /**使用firstTask和來自線程工廠中的線程創建了 Worker 對象*/
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    /**將run方法委託給runWorker執行*/
    public void run() {
        runWorker(this);
    }
}

Worker 類實現 Runnable 接口， Worker 類的構造方法中 this.thread = getThreadFactory().newThread(this)比較關鍵，這行代碼的意思是說使用當前 Worker 對象創建了一個線程，那其實也就是說 thread 對象和當前 Worker 對象中調用的 run 方法是一樣的。到這一步我們可以得出上一步 addWorker 方法中的 t.start 調用的其實就是 Worker 類中的 run方法。

那 runWorker 又是如何運行的呢？

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    //獲取要執行的任務
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    
    //輪詢調用 getTask 用於獲取任務
    while (task != null || (task = getTask()) != null) {
        w.lock();
        //省略部分代碼
            ......
        //執行run方法
        task.run();
        //省略部分代碼
            ......
    }
}

runWorker 中使用 while 循環，不斷調用 getTask 去獲取新任務。

最後看下 getTask 方法做了哪些事：

private Runnable getTask() {
    boolean timedOut = false; 
    //無限循環
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 檢查隊列是否爲空
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        
        //獲取運行線程數，根據allowCoreThreadTimeOut決定是否允許定時等待
        int wc = workerCountOf(c);
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        //線程超時並且隊列爲空時通過CAS將實際運行線程數減1
        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;
            //繼續循環，並且置超時標識爲true
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

通過以上源碼可以看出：

在for無限循環中，通過不斷的檢查線程池狀態和隊列容量，來獲取可執行任務；
在 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();代碼中，分爲兩種情況
- timed 爲 true，允許淘汰 Worker，即實際運行的線程，則通過
  workQueue.poll的方式定時等待拉取任務，如果在指定keepAliveTime時間內獲取任務則返回，如果沒有任務則繼續for循環並直到timed等於false；
- timed 爲 false，則會調用 workQueue.take 方法，隊列中 take 方法的含義是當隊列有任務時，立即返回隊首任務，沒有任務時則一直阻塞當前線程，直到有新任務才返回。

下面簡單畫了一下核心線程的序列圖：

結論

線程池當未調用 shutdown 方法時，是通過隊列的 take 方法阻塞核心線程（Worker）的 run 方法從而保證核心線程不被銷燬的。

Java線程池是如何保證核心線程不被銷燬的

ThreadPoolExecutor 成員變量和方法介紹

案例分析

結論

Mybatis數據源類型和連接池實現原理源碼分析

linux下打開目錄~和/的區別

Mybatis通過MapperScannerConfigurer掃描basePackage源碼分析

Mybatis啓動初始化過程源碼分析

Mybaits事務管理的實現原理源碼分析

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結