新手一看就懂的執行緒池！

經過前幾篇文章的學習，大家對多執行緒應該有些瞭解了吧，這裡附上前三篇文章的連結，還沒有看過的小夥伴快去複習吧～～

多執行緒基礎篇入門

執行緒的生命週期和常用 APIs

生產者消費者問題

那相信大家也能感受到，其實用多執行緒是很麻煩的，包括執行緒的建立、銷燬和排程等等，而且我們平時工作時好像也並沒有這樣來 new 一個執行緒，其實是因為很多框架的底層都用到了執行緒池。

執行緒池是幫助我們管理執行緒的工具，它維護了多個執行緒，可以降低資源的消耗，提高系統的效能。

並且通過使用執行緒池，我們開發人員可以更好的把精力放在任務程式碼上，而不去管執行緒是如何執行的，實現任務提交和執行的解藕。

本文將從是何、為何、如何的角度來講解執行緒池：

1. 執行緒池是什麼
2. 為什麼要用執行緒池
3. 怎麼用執行緒池

執行緒池 Thread Pool

執行緒池是一種池化的技術，類似的還有資料庫連線池、HTTP 連線池等等。

池化的思想主要是為了減少每次獲取和結束資源的消耗，提高對資源的利用率。

比如在一些偏遠地區打水不方便的，大家會每段時間把水打過來存在池子裡，這樣平時用的時候就直接來取就好了。

執行緒池同理，正是因為每次建立、銷燬執行緒需要佔用太多系統資源，所以我們建這麼一個池子來統一管理執行緒。用的時候從池子裡拿，不用了就放回來，也不用你銷燬，是不是方便了很多？

Java 中的執行緒池是由 juc 即 java.util.concurrent 包來實現的，最主要的就是 ThreadPoolExecutor 這個類。具體怎麼用我們下文再說。

執行緒池的好處

在多執行緒的第一篇文章中我們說過，程式會申請資源，拿來給執行緒用，所以執行緒是很佔用系統資源的，那麼我們用執行緒池來統一管理執行緒就能夠很好的解決這種資源管理問題。

比如因為不需要建立、銷燬執行緒，每次需要用的時候我就去拿，用完了之後再放回去，所以節省了很多資源開銷，可以提高系統的執行速度。

而統一的管理和排程，可以合理分配內部資源，根據系統的當前情況調整執行緒的數量。

那總結來說有以下 3 個好處：

1. 降低資源消耗：通過重複利用現有的執行緒來執行任務，避免多次建立和銷燬執行緒。
2. 提高相應速度：因為省去了建立執行緒這個步驟，所以在拿到任務時，可以立刻開始執行。
3. 提供附加功能：執行緒池的可擴充性使得我們可以自己加入新的功能，比如說定時、延時來執行某些執行緒。

說了這麼多，終於到了今天的重點，我們來看下究竟怎麼用執行緒池吧～

執行緒池的實現

Java 給我們提供了 Executor 介面來使用執行緒池。

我們常用的執行緒池有這兩大類：

• ThreadPoolExecutor
• ScheduledThreadPoolExecutor

它倆的區別呢，就是第一個是普通的，第二個是可以定時執行的。

當然還有其他執行緒池，比如 JDK 1.7 才出現的 ForkJoinPool ，可以把大任務分割成小任務來執行，最後再大一統。

那麼任務提交到一個執行緒池之後，它會經歷一個怎樣的過程呢？

執行過程

執行緒池在內部實際上採用了生產者消費者模型（還不清楚這個模型的在文章開頭有改文章的連結）將執行緒和任務解藕，從而使執行緒池同時管理任務和執行緒。

當任務提交到執行緒池裡之後，需要經過以下流程：

1. 首先它檢查核心執行緒池是否已滿。這個核心執行緒池，就是不管使用者量多少執行緒池始終維護的執行緒的池子。比如說執行緒池的總容量最多能裝 100 個執行緒，核心執行緒池我們設定為 50，那麼就無論使用者量有多少，都保持 50 個執行緒活著。這個數字當然是根據具體的業務需求來決定的。
2. 阻塞佇列，就是 BlockingQueue ，在生產者消費者這節裡提到過。
3. 最後判斷執行緒池是否已滿，就是判斷是不是已經有 100 個執行緒了，而不是 50 個。
4. 如果已經滿了，所以不能繼續建立執行緒了，就需要按照飽和策略或者叫做拒絕策略來處理。這個飽和策略我們下文再講。

ThreadPoolExecutor

我們主要說下 ThreadPoolExecutor ，它是最常用的執行緒池。

這裡我們可以看到，這個類裡有 4 個構造方法，點進去仔細看，其實前三個都 call 了最後一個，所以我們只需要看最後一個就好。

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

這裡我們來仔細看下這幾個引數：

1. corePoolSize：這個就是上文提到過的核心執行緒池的大小，在核心裡的執行緒是永遠不會失業的。

corePoolSize the number of threads to keep in the pool, even if they are idle, unless {@code allowCoreThreadTimeOut} is set

2. maximumPoolSize：執行緒池的最大容量。

maximumPoolSize the maximum number of threads to allow in the pool

3. keepAliveTime：存活時間。這個時間指的是，當執行緒池中的執行緒數量大於核心執行緒數，這些執行緒閒著之後，多久銷燬它們。

keepAliveTime when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating.

4. unit：對應上面存活時間的時間單位。

unit the time unit for the {@code keepAliveTime} argument

5. workQueue：這是一個阻塞佇列，其實執行緒池也是生產者消費者模型的一種，任務 - 相當於生產者，執行緒 - 相當於消費者，所以這個阻塞佇列是用來協調生產和消費的進度的。

workQueue the queue to use for holding tasks before they are executed.

6. threadFactory：這裡用到了工程模式，用來建立執行緒的。

threadFactory the factory to use when the executor creates a new thread

7. handler：這個就是拒絕策略。

handler the handler to use when execution is blocked because the thread bounds and queue capacities are reached

所以我們可以通過自己傳入這 7 個引數構造執行緒池，當然了，貼心的 Java 也給我們包裝好了幾類執行緒池可以很方便的拿來使用。

• newCachedThreadPool
• newFixedThreadPool
• newSingleThreadExecutor

我們具體來看每個的含義和用法。

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

這裡我們可以看到，

• 核心執行緒池數量為 0，也就是它不會永久保留任何執行緒；
• 最大容量是 Integer.MAX_VALUE；
• 每個執行緒的存活時間是 60 秒，也就是如果 1 分鐘沒有用這個執行緒就被回收了；
• 最後用到了同步佇列。

它的適用場景在原始碼裡有說：

These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks.

來看怎麼用：

public class newCacheThreadPool {

    public static void main(String[] args) {
        // 建立一個執行緒池
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 向執行緒池提交任務
        for (int i = 0; i < 50; i++) {
            executorService.execute(new Task());//執行緒池執行任務
        }
        executorService.shutdown();
    }
}

執行結果：

可以很清楚的看到，執行緒 1、2、3、5、6 都很快重用了。

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

這個執行緒池的特點是：

1. 執行緒池中的執行緒數量是固定的，也是我們建立執行緒池時需要穿入的引數；
2. 超出這個數量的執行緒就需要在佇列中等待。

它的適用場景是：

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.

public class FixedThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 200; i++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

這裡我限制了執行緒池裡最多有 10 個執行緒，哪怕有 200 個任務需要執行，也只有 1-10 這 10 個執行緒可以執行。

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

這個執行緒池顧名思義，裡面只有 1 個執行緒。

適用場景是：

Creates an Executor that uses a single worker thread operating off an unbounded queue.

我們來看下效果。

public class SingleThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Task());
        }
        executorService.shutdown();
    }
}

這裡在出結果的時候我能夠明顯的感覺到有些卡頓，這在前兩個例子裡是沒有的，畢竟這裡只有一個執行緒在執行嘛。

小結

所以在使用執行緒池時，其實都是呼叫的 ThreadPoolExecutor 這個類，只不過傳遞的不同引數。

這裡要特別注意兩個引數：

• 一是 workQueue 的選擇，這個就是阻塞佇列的選擇，如果要說還得這麼一大篇文章，之後有機會再寫吧。
• 二是 handler 的設定。

那我們發現，在上面的 3 個具體執行緒池裡，其實都沒有設定 handler，這是因為它們都使用了 defaultHandler。

/**
 * The default rejected execution handler
 */
private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();

在 ThreadPoolExecutor 裡有 4 種拒絕策略，這 4 種策略都是 implements 了 RejectedExecutionHandler：

1. AbortPolicy 表示拒絕任務並丟擲一個異常 RejectedExecutionException。這個我稱之為“正式拒絕”，比如你面完了最後一輪面試，最終接到 HR 的拒信。
2. DiscardPolicy 拒絕任務但不吭聲。這個就是“默拒”，比如大部分公司拒簡歷的時候都是默拒。
3. DiscardOldestPolicy 顧名思義，就是把老的任務丟掉，執行新任務。
4. CallerRunsPolicy 直接呼叫執行緒處理該任務，就是 VIP 嘛。

所以這 3 種執行緒池都使用的預設策略也就是第一種，光明正大的拒絕。

好了以上就是本文的所有內容了。當然執行緒池還有很多知識點，比如 execute() 和 submit() 方法，執行緒池的生命週期等等。

但隨著閱讀量的逐漸走低，齊姐意識到了這似乎有什麼誤會，所以這篇文章是多執行緒系列的最後一篇了。

本文已收錄至我的 Github 上：https://github.com/xiaoqi6666/NYCSDE，點選閱讀原文直達，這個 Github 彙總了我所有的文章和資料，之後也會一直更新和維護，還希望大家幫忙點個 Star，你們的支援和認可，就是我創作的最大動力！

我是小齊，終生學習者，每天晚上 9 點，雲自習室裡不見不散！