Java線程池原理與源碼詳細解讀，不再怕面試問線程池了！

時間  2019-11-22
標籤 java 線程 原理 源碼 詳細 解讀 不再 面試 欄目 Java 简体版
原文   原文鏈接

線程池java

「線程池」，顧名思義就是一個線程緩存，線程是稀缺資源，若是被無限制的建立，不只會消耗系統資源，還會下降系統的穩定性，所以Java中提供線程池對線程進行統一分配、調優和監控。程序員

v2-6557eb22c58091aeef5938a1701a2aa0_hd.png

線程池介紹web

在web開發中，服務器須要接受並處理請求，因此會爲一個請求來分配一個線程來進行處理。若是每次請求都新建立一個線程的話實現起來很是簡便，可是存在一個問題：面試

若是併發的請求數量很是多，但每一個線程執行的時間很短，這樣就會頻繁的建立和銷燬線程，如此一來會大大下降系統的效率。可能出現服務器在爲每一個請求建立新線程和銷燬線程上花費的時間和消耗的系統資源要比處理實際的用戶請求的時間和資源更多。數組

那麼有沒有一種辦法使執行完一個任務，並不被銷燬，而是能夠繼續執行其餘的任務呢？緩存

這就是線程池的目的了。線程池爲線程生命週期的開銷和資源不足問題提供瞭解決方案。經過對多個任務重用線程，線程建立的開銷被分攤到了多個任務上。服務器

何時使用線程池？多線程

  • 單個任務處理時間比較短併發

  • 須要處理的任務數量很大app

線程池優點

  • 重用存在的線程，減小線程建立，消亡的開銷，提升性能

  • 提升響應速度。當任務到達時，任務能夠不須要的等到線程建立就能當即執行。

  • 提升線程的可管理性。線程是稀缺資源，若是無限制的建立，不只會消耗系統資源，還會下降系統的穩定性，使用線程池能夠進行統一的分配，調優和監控。

線程的實現方式

Runnable,Thread,Callable

// 實現Runnable接口的類將被Thread執行，表示一個基本的任務

public interface Runnable {

// run方法就是它全部的內容，就是實際執行的任務

public abstract void run();

}

//Callable一樣是任務，與Runnable接口的區別在於它接收泛型，同時它執行任務後帶有返回內容

public interface Callable<V> {

// 相對於run方法的帶有返回值的call方法

V call() throws Exception;

}

Executor框架

Executor接口是線程池框架中最基礎的部分，定義了一個用於執行Runnable的execute方法。

下圖爲它的繼承與實現

v2-d1163ae7cd6ad820c34df6bc5d7224e1_hd.jpg


從圖中能夠看出Executor下有一個重要子接口ExecutorService，其中定義了線程池的具體行爲

1，execute（Runnable command）：履行Ruannable類型的任務,

2，submit（task）：可用來提交Callable或Runnable任務，並返回表明此任務的Future對象

3，shutdown（）：在完成已提交的任務後封閉辦事，再也不接管新任務,

4，shutdownNow（）：中止全部正在履行的任務並封閉辦事。

5，isTerminated（）：測試是否全部任務都履行完畢了。

6，isShutdown（）：測試是否該ExecutorService已被關閉。

v2-802cdeae9d6a56301c9c17b3e99717a8_hd.png

線程池重點屬性

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;

ctl 是對線程池的運行狀態和線程池中有效線程的數量進行控制的一個字段， 它包含兩部分的信息: 線程池的運行狀態 (runState) 和線程池內有效線程的數量 (workerCount)，這裏能夠看到，使用了Integer類型來保存，高3位保存runState，低29位保存workerCount。COUNT_BITS 就是29，CAPACITY就是1左移29位減1（29個1），這個常量表示workerCount的上限值，大約是5億。


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

  • runStateOf：獲取運行狀態；

  • workerCountOf：獲取活動線程數；

  • ctlOf：獲取運行狀態和活動線程數的值。

線程池存在5種狀態

RUNNING = -1 << COUNT_BITS; //高3位爲111

SHUTDOWN = 0 << COUNT_BITS; //高3位爲000

STOP = 1 << COUNT_BITS; //高3位爲001

TIDYING = 2 << COUNT_BITS; //高3位爲010

TERMINATED = 3 << COUNT_BITS; //高3位爲011

一、RUNNING

(1) 狀態說明：線程池處在RUNNING狀態時，可以接收新任務，以及對已添加的任務進行處理。

(02) 狀態切換：線程池的初始化狀態是RUNNING。換句話說，線程池被一旦被建立，就處於RUNNING狀態，而且線程池中的任務數爲0！

二、 SHUTDOWN

(1) 狀態說明：線程池處在SHUTDOWN狀態時，不接收新任務，但能處理已添加的任務。

(2) 狀態切換：調用線程池的shutdown()接口時，線程池由RUNNING -> SHUTDOWN。

三、STOP

(1) 狀態說明：線程池處在STOP狀態時，不接收新任務，不處理已添加的任務，而且會中斷正在處理的任務。

(2) 狀態切換：調用線程池的shutdownNow()接口時，線程池由(RUNNING or SHUTDOWN ) -> STOP。

四、TIDYING

(1) 狀態說明：當全部的任務已終止，ctl記錄的」任務數量」爲0，線程池會變爲TIDYING狀態。當線程池變爲TIDYING狀態時，會執行鉤子函數terminated()。terminated()在ThreadPoolExecutor類中是空的，若用戶想在線程池變爲TIDYING時，進行相應的處理；能夠經過重載terminated()函數來實現。

(2) 狀態切換：當線程池在SHUTDOWN狀態下，阻塞隊列爲空而且線程池中執行的任務也爲空時，就會由 SHUTDOWN -> TIDYING。 當線程池在STOP狀態下，線程池中執行的任務爲空時，就會由STOP -> TIDYING。

五、 TERMINATED

(1) 狀態說明：線程池完全終止，就變成TERMINATED狀態。

(2) 狀態切換：線程池處在TIDYING狀態時，執行完terminated()以後，就會由 TIDYING -> TERMINATED。

進入TERMINATED的條件以下：

  • 線程池不是RUNNING狀態；

  • 線程池狀態不是TIDYING狀態或TERMINATED狀態；

  • 若是線程池狀態是SHUTDOWN而且workerQueue爲空；

  • workerCount爲0；

  • 設置TIDYING狀態成功。

v2-abd400ab183777a343c0888d87cc7f5a_hd.jpg

線程池的具體實現

ThreadPoolExecutor 默認線程池

ScheduledThreadPoolExecutor 定時線程池

ThreadPoolExecutor線程池的建立

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

任務提交

一、public void execute() //提交任務無返回值
二、public Future<?> submit() //任務執行完成後有返回值


參數解釋

corePoolSize

線程池中的核心線程數，當提交一個任務時，線程池建立一個新線程執行任務，直到當前線程數等於corePoolSize；若是當前線程數爲corePoolSize，繼續提交的任務被保存到阻塞隊列中，等待被執行；若是執行了線程池的prestartAllCoreThreads()方法，線程池會提早建立並啓動全部核心線程。

maximumPoolSize

線程池中容許的最大線程數。若是當前阻塞隊列滿了，且繼續提交任務，則建立新的線程執行任務，前提是當前線程數小於maximumPoolSize；

keepAliveTime

線程池維護線程所容許的空閒時間。當線程池中的線程數量大於corePoolSize的時候，若是這時沒有新的任務提交，核心線程外的線程不會當即銷燬，而是會等待，直到等待的時間超過了keepAliveTime；

unit

keepAliveTime的單位；

workQueue

用來保存等待被執行的任務的阻塞隊列，且任務必須實現Runable接口，在JDK中提供了以下阻塞隊列：

  • 一、ArrayBlockingQueue：基於數組結構的有界阻塞隊列，按FIFO排序任務；

  • 二、LinkedBlockingQuene：基於鏈表結構的阻塞隊列，按FIFO排序任務，吞吐量一般要高於ArrayBlockingQuene；

  • 三、SynchronousQuene：一個不存儲元素的阻塞隊列，每一個插入操做必須等到另外一個線程調用移除操做，不然插入操做一直處於阻塞狀態，吞吐量一般要高於LinkedBlockingQuene；

  • 四、priorityBlockingQuene：具備優先級的***阻塞隊列；

threadFactory

它是ThreadFactory類型的變量，用來建立新線程。默認使用Executors.defaultThreadFactory() 來建立線程。使用默認的ThreadFactory來建立線程時，會使新建立的線程具備相同的NORM_PRIORITY優先級而且是非守護線程，同時也設置了線程的名稱。歡迎你們關注個人公種浩【程序員追風】，整理了2019年多家公司java面試題資料100多頁pdf文檔，文章都會在裏面更新，整理的資料也會放在裏面。

handler

線程池的飽和策略，當阻塞隊列滿了，且沒有空閒的工做線程，若是繼續提交任務，必須採起一種策略處理該任務，線程池提供了4種策略：

  • 一、AbortPolicy：直接拋出異常，默認策略；

  • 二、CallerRunsPolicy：用調用者所在的線程來執行任務；

  • 三、DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，並執行當前任務；

  • 四、DiscardPolicy：直接丟棄任務；

上面的4種策略都是ThreadPoolExecutor的內部類。

固然也能夠根據應用場景實現RejectedExecutionHandler接口，自定義飽和策略，如記錄日誌或持久化存儲不能處理的任務。

v2-930c3b4ee609b00a961ecfdb16774584_hd.png

線程池監控

public long getTaskCount() //線程池已執行與未執行的任務總數
public long getCompletedTaskCount() //已完成的任務數
public int getPoolSize() //線程池當前的線程數
public int getActiveCount() //線程池中正在執行任務的線程數量

線程池原理

v2-54e69cac13a1ba767ac25a14254c2d08_hd.jpg


源碼分析

execute方法

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
/*
 * clt記錄着runState和workerCount
 */
    int c = ctl.get();
/*
 * workerCountOf方法取出低29位的值，表示當前活動的線程數；
 * 若是當前活動線程數小於corePoolSize，則新建一個線程放入線程池中；
 * 並把任務添加到該線程中。
 */
    if (workerCountOf(c) < corePoolSize) {
        /*
         * addWorker中的第二個參數表示限制添加線程的數量是根據corePoolSize來判斷仍是maximumPoolSize來判斷；
         * 若是爲true，根據corePoolSize來判斷；
         * 若是爲false，則根據maximumPoolSize來判斷
         */
        if (addWorker(command, true))
            return;
/*
 * 若是添加失敗，則從新獲取ctl值
 */
        c = ctl.get();
    }
/*
 * 若是當前線程池是運行狀態而且任務添加到隊列成功
 */
    if (isRunning(c) && workQueue.offer(command)) {
        // 從新獲取ctl值
        int recheck = ctl.get();
         // 再次判斷線程池的運行狀態，若是不是運行狀態，因爲以前已經把command添加到workQueue中了，
        // 這時須要移除該command
        // 執行事後經過handler使用拒絕策略對該任務進行處理，整個方法返回
        if (! isRunning(recheck) && remove(command))
            reject(command);
        /*
         * 獲取線程池中的有效線程數，若是數量是0，則執行addWorker方法
         * 這裏傳入的參數表示：
         * 1. 第一個參數爲null，表示在線程池中建立一個線程，但不去啓動；
         * 2. 第二個參數爲false，將線程池的有限線程數量的上限設置爲maximumPoolSize，添加線程時根據maximumPoolSize來判斷；
         * 若是判斷workerCount大於0，則直接返回，在workQueue中新增的command會在未來的某個時刻被執行。
         */
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
/*
 * 若是執行到這裏，有兩種狀況：
 * 1. 線程池已經不是RUNNING狀態；
 * 2. 線程池是RUNNING狀態，但workerCount >= corePoolSize而且workQueue已滿。
 * 這時，再次調用addWorker方法，但第二個參數傳入爲false，將線程池的有限線程數量的上限設置爲maximumPoolSize；
 * 若是失敗則拒絕該任務
 */
    else if (!addWorker(command, false))
        reject(command);
}

簡單來講，在執行execute()方法時若是狀態一直是RUNNING時，的執行過程以下：

  1. 若是workerCount < corePoolSize，則建立並啓動一個線程來執行新提交的任務；

  2. 若是workerCount >= corePoolSize，且線程池內的阻塞隊列未滿，則將任務添加到該阻塞隊列中；

  3. 若是workerCount >= corePoolSize && workerCount < maximumPoolSize，且線程池內的阻塞隊列已滿，則建立並啓動一個線程來執行新提交的任務；

  4. 若是workerCount >= maximumPoolSize，而且線程池內的阻塞隊列已滿, 則根據拒絕策略來處理該任務, 默認的處理方式是直接拋異常。

這裏要注意一下addWorker(null, false);，也就是建立一個線程，但並無傳入任務，由於任務已經被添加到workQueue中了，因此worker在執行的時候，會直接從workQueue中獲取任務。因此，在workerCountOf(recheck) == 0時執行addWorker(null, false);也是爲了保證線程池在RUNNING狀態下必需要有一個線程來執行任務。

execute方法執行流程以下：

v2-ef4ebf5bc96f7ac1eae55af84819b638_hd.jpg


addWorker方法

addWorker方法的主要工做是在線程池中建立一個新的線程並執行，firstTask參數 用於指定新增的線程執行的第一個任務，core參數爲true表示在新增線程時會判斷當前活動線程數是否少於corePoolSize，false表示新增線程前須要判斷當前活動線程數是否少於maximumPoolSize，代碼以下：

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
    // 獲取運行狀態
        int rs = runStateOf(c);
    /*
     * 這個if判斷
     * 若是rs >= SHUTDOWN，則表示此時再也不接收新任務；
     * 接着判斷如下3個條件，只要有1個不知足，則返回false：
     * 1. rs == SHUTDOWN，這時表示關閉狀態，再也不接受新提交的任務，但卻能夠繼續處理阻塞隊列中已保存的任務
     * 2. firsTask爲空
     * 3. 阻塞隊列不爲空
     * 
     * 首先考慮rs == SHUTDOWN的狀況
     * 這種狀況下不會接受新提交的任務，因此在firstTask不爲空的時候會返回false；
     * 而後，若是firstTask爲空，而且workQueue也爲空，則返回false，
     * 由於隊列中已經沒有任務了，不須要再添加線程了
     */
     // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                        firstTask == null &&
                        ! workQueue.isEmpty()))
            return false;
        for (;;) {
            // 獲取線程數
            int wc = workerCountOf(c);
            // 若是wc超過CAPACITY，也就是ctl的低29位的最大值（二進制是29個1），返回false；
            // 這裏的core是addWorker方法的第二個參數，若是爲true表示根據corePoolSize來比較，
            // 若是爲false則根據maximumPoolSize來比較。
            // 
            if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 嘗試增長workerCount，若是成功，則跳出第一個for循環
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 若是增長workerCount失敗，則從新獲取ctl的值
            c = ctl.get();  // Re-read ctl
            // 若是當前的運行狀態不等於rs，說明狀態已被改變，返回第一個for循環繼續執行
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
     // 根據firstTask來建立Worker對象
        w = new Worker(firstTask);
     // 每個Worker對象都會建立一個線程
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                int rs = runStateOf(ctl.get());
                // rs < SHUTDOWN表示是RUNNING狀態；
                // 若是rs是RUNNING狀態或者rs是SHUTDOWN狀態而且firstTask爲null，向線程池中添加線程。
                // 由於在SHUTDOWN時不會在添加新的任務，但仍是會執行workQueue中的任務
                if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // workers是一個HashSet
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize記錄着線程池中出現過的最大線程數量
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                // 啓動線程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

Worker類

線程池中的每個線程被封裝成一個Worker對象，ThreadPool維護的其實就是一組Worker對象，請參見JDK源碼。

Worker類繼承了AQS，並實現了Runnable接口，注意其中的firstTask和thread屬性：firstTask用它來保存傳入的任務；thread是在調用構造方法時經過ThreadFactory來建立的線程，是用來處理任務的線程。

在調用構造方法時，須要把任務傳入，這裏經過getThreadFactory().newThread(this);來新建一個線程，newThread方法傳入的參數是this，由於Worker自己繼承了Runnable接口，也就是一個線程，因此一個Worker對象在啓動的時候會調用Worker類中的run方法。

Worker繼承了AQS，使用AQS來實現獨佔鎖的功能。爲何不使用ReentrantLock來實現呢？能夠看到tryAcquire方法，它是不容許重入的，而ReentrantLock是容許重入的：

  1. lock方法一旦獲取了獨佔鎖，表示當前線程正在執行任務中；

  2. 若是正在執行任務，則不該該中斷線程；

  3. 若是該線程如今不是獨佔鎖的狀態，也就是空閒的狀態，說明它沒有在處理任務，這時能夠對該線程進行中斷；

  4. 線程池在執行shutdown方法或tryTerminate方法時會調用interruptIdleWorkers方法來中斷空閒的線程，interruptIdleWorkers方法會使用tryLock方法來判斷線程池中的線程是不是空閒狀態；

  5. 之因此設置爲不可重入，是由於咱們不但願任務在調用像setCorePoolSize這樣的線程池控制方法時從新獲取鎖。若是使用ReentrantLock，它是可重入的，這樣若是在任務中調用瞭如setCorePoolSize這類線程池控制的方法，會中斷正在運行的線程。

因此，Worker繼承自AQS，用於判斷線程是否空閒以及是否能夠被中斷。

此外，在構造方法中執行了setState(-1);，把state變量設置爲-1，爲何這麼作呢？是由於AQS中默認的state是0，若是剛建立了一個Worker對象，尚未執行任務時，這時就不該該被中斷，看一下tryAquire方法：

protected boolean tryAcquire(int unused) {
    //cas修改state，不可重入
    if (compareAndSetState(0, 1)) { 
        setExclusiveOwnerThread(Thread.currentThread());
        return true;
    }
    return false;
}

tryAcquire方法是根據state是不是0來判斷的，因此，setState(-1);將state設置爲-1是爲了禁止在執行任務前對線程進行中斷。

正由於如此，在runWorker方法中會先調用Worker對象的unlock方法將state設置爲0。

runWorker方法

在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 {
        // 若是task爲空，則經過getTask來獲取任務
        while (task != null || (task = getTask()) != null) {
            w.lock();
            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;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

這裏說明一下第一個if判斷，目的是：

  • 若是線程池正在中止，那麼要保證當前線程是中斷狀態；

  • 若是不是的話，則要保證當前線程不是中斷狀態；

這裏要考慮在執行該if語句期間可能也執行了shutdownNow方法，shutdownNow方法會把狀態設置爲STOP，回顧一下STOP狀態：

不能接受新任務，也不處理隊列中的任務，會中斷正在處理任務的線程。在線程池處於 RUNNING 或 SHUTDOWN 狀態時，調用 shutdownNow() 方法會使線程池進入到該狀態。

STOP狀態要中斷線程池中的全部線程，而這裏使用Thread.interrupted()來判斷是否中斷是爲了確保在RUNNING或者SHUTDOWN狀態時線程是非中斷狀態的，由於Thread.interrupted()方法會復位中斷的狀態。

總結一下runWorker方法的執行過程：

  1. while循環不斷地經過getTask()方法獲取任務；

  2. getTask()方法從阻塞隊列中取任務；

  3. 若是線程池正在中止，那麼要保證當前線程是中斷狀態，不然要保證當前線程不是中斷狀態；

  4. 調用task.run()執行任務；

  5. 若是task爲null則跳出循環，執行processWorkerExit()方法；

  6. runWorker方法執行完畢，也表明着Worker中的run方法執行完畢，銷燬線程。

這裏的beforeExecute方法和afterExecute方法在ThreadPoolExecutor類中是空的，留給子類來實現。

completedAbruptly變量來表示在執行任務過程當中是否出現了異常，在processWorkerExit方法中會對該變量的值進行判斷。


getTask方法

getTask方法用來從阻塞隊列中取任務，代碼以下：

private Runnable getTask() {
    // timeOut變量的值表示上次從阻塞隊列中取任務時是否超時
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // Check if queue empty only if necessary.
    /*
     * 若是線程池狀態rs >= SHUTDOWN，也就是非RUNNING狀態，再進行如下判斷：
     * 1. rs >= STOP，線程池是否正在stop；
     * 2. 阻塞隊列是否爲空。
     * 若是以上條件知足，則將workerCount減1並返回null。
     * 由於若是當前線程池狀態的值是SHUTDOWN或以上時，不容許再向阻塞隊列中添加任務。
     */
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        int wc = workerCountOf(c);
        // Are workers subject to culling?
        // timed變量用於判斷是否須要進行超時控制。
        // allowCoreThreadTimeOut默認是false，也就是核心線程不容許進行超時；
        // wc > corePoolSize，表示當前線程池中的線程數量大於核心線程數量；
        // 對於超過核心線程數量的這些線程，須要進行超時控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

    /*
     * wc > maximumPoolSize的狀況是由於可能在此方法執行階段同時執行了setMaximumPoolSize方法；
     * timed && timedOut 若是爲true，表示當前操做須要進行超時控制，而且上次從阻塞隊列中獲取任務發生了超時
     * 接下來判斷，若是有效線程數量大於1，或者阻塞隊列是空的，那麼嘗試將workerCount減1；
     * 若是減1失敗，則返回重試。
     * 若是wc == 1時，也就說明當前線程是線程池中惟一的一個線程了。
     */
        if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        try {
        /*
         * 根據timed來判斷，若是爲true，則經過阻塞隊列的poll方法進行超時控制，若是在keepAliveTime時間內沒有獲取到任務，則返回null；
         * 不然經過take方法，若是這時隊列爲空，則take方法會阻塞直到隊列不爲空。
         *
         */
            Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
            if (r != null)
                return r;
            // 若是 r == null，說明已經超時，timedOut設置爲true
            timedOut = true;
        } catch (InterruptedException retry) {
            // 若是獲取任務時當前線程發生了中斷，則設置timedOut爲false並返回循環重試
            timedOut = false;
        }
    }
}

這裏重要的地方是第二個if判斷，目的是控制線程池的有效線程數量。由上文中的分析能夠知道，在執行execute方法時，若是當前線程池的線程數量超過了corePoolSize且小於maximumPoolSize，而且workQueue已滿時，則能夠增長工做線程，但這時若是超時沒有獲取到任務，也就是timedOut爲true的狀況，說明workQueue已經爲空了，也就說明了當前線程池中不須要那麼多線程來執行任務了，能夠把多於corePoolSize數量的線程銷燬掉，保持線程數量在corePoolSize便可。

何時會銷燬？固然是runWorker方法執行完以後，也就是Worker中的run方法執行完，由JVM自動回收。

getTask方法返回null時，在runWorker方法中會跳出while循環，而後會執行processWorkerExit方法。


processWorkerExit方法

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 若是completedAbruptly值爲true，則說明線程執行時出現了異常，須要將workerCount減1；
    // 若是線程執行時沒有出現異常，說明在getTask()方法中已經已經對workerCount進行了減1操做，這裏就沒必要再減了。  
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //統計完成的任務數
        completedTaskCount += w.completedTasks;
        // 從workers中移除，也就表示着從線程池中移除了一個工做線程
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
    // 根據線程池狀態進行判斷是否結束線程池
    tryTerminate();
    int c = ctl.get();
/*
 * 當線程池是RUNNING或SHUTDOWN狀態時，若是worker是異常結束，那麼會直接addWorker；
 * 若是allowCoreThreadTimeOut=true，而且等待隊列有任務，至少保留一個worker；
 * 若是allowCoreThreadTimeOut=false，workerCount很多於corePoolSize。
 */
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

至此，processWorkerExit執行完以後，工做線程被銷燬，以上就是整個工做線程的生命週期，從execute方法開始，Worker使用ThreadFactory建立新的工做線程，runWorker經過getTask獲取任務，而後執行任務，若是getTask返回null，進入processWorkerExit方法，整個線程結束，如圖所示：

v2-2298a9eebdfb55479fd90ffb35851c81_hd.jpg


總結

  • 分析了線程的建立，任務的提交，狀態的轉換以及線程池的關閉；

  • 這裏經過execute方法來展開線程池的工做流程，execute方法經過corePoolSize，maximumPoolSize以及阻塞隊列的大小來判斷決定傳入的任務應該被當即執行，仍是應該添加到阻塞隊列中，仍是應該拒絕任務。

  • 介紹了線程池關閉時的過程，也分析了shutdown方法與getTask方法存在競態條件；

  • 在獲取任務時，要經過線程池的狀態來判斷應該結束工做線程仍是阻塞線程等待新的任務，也解釋了爲何關閉線程池時要中斷工做線程以及爲何每個worker都須要lock。

最後

歡迎你們一塊兒交流，喜歡文章記得點個贊喲，感謝支持！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程