新手一看就懂的執行緒池！-有解無憂

經過前幾篇文章的學習，大家對多執行緒應該有些了解了吧，這里附上前三篇文章的鏈接，還沒有看過的小伙伴快去復習吧～～

多執行緒基礎篇入門

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

生產者消費者問題

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

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

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

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

執行緒池是什么
為什么要用執行緒池
怎么用執行緒池

執行緒池 Thread Pool

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

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

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

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

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

執行緒池的好處

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

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

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

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

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

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

執行緒池的實作

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

Executor

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

ThreadPoolExecutor
ScheduledThreadPoolExecutor

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

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

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

執行程序

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

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

執行程序

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

ThreadPoolExecutor

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

ThreadPoolExecutor Structure

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

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

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

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

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

maximumPoolSize：執行緒池的最大容量，

maximumPoolSize the maximum number of threads to allow in the pool

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.

unit：對應上面存活時間的時間單位，

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

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

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

threadFactory：這里用到了工程模式，用來創建執行緒的，

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

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

執行結果：

newCached 結果

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

newFixedThreadPool

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

這個執行緒池的特點是：

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

它的適用場景是：

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

newFixed 結果

這里我限制了執行緒池里最多有 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();
    }
}

newSingle 結果

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

小結

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

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

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

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

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

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

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

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

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

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

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

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/224895.html

標籤：其他

上一篇：GPS對時系統（GPS對時系統）計算機網路必備品

下一篇：騰訊云容器服務 TKE 推出新一代零損耗容器網路