那相信大家也能感受到，其實用多線程是很麻煩的，包括線程的創(chuàng)建、銷毀和調(diào)度等等，而且我們平時工作時好像也并沒有這樣來 new 一個線程，其實是因為很多框架的底層都用到了線程池。

[[342941]]

線程池是幫助我們管理線程的工具，它維護了多個線程，可以降低資源的消耗，提高系統(tǒng)的性能。

并且通過使用線程池，我們開發(fā)人員可以更好的把精力放在任務(wù)代碼上，而不去管線程是如何執(zhí)行的，實現(xiàn)任務(wù)提交和執(zhí)行的解藕。

本文將從是何、為何、如何的角度來講解線程池：

1. 線程池是什么
2. 為什么要用線程池
3. 怎么用線程池

線程池 Thread Pool

線程池是一種池化的技術(shù)，類似的還有數(shù)據(jù)庫連接池、HTTP 連接池等等。

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

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

線程池同理，正是因為每次創(chuàng)建、銷毀線程需要占用太多系統(tǒng)資源，所以我們建這么一個池子來統(tǒng)一管理線程。用的時候從池子里拿，不用了就放回來，也不用你銷毀，是不是方便了很多?

Java 中的線程池是由 juc 即 java.util.concurrent 包來實現(xiàn)的，最主要的就是 ThreadPoolExecutor 這個類。具體怎么用我們下文再說。

線程池的好處

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

比如因為不需要創(chuàng)建、銷毀線程，每次需要用的時候我就去拿，用完了之后再放回去，所以節(jié)省了很多資源開銷，可以提高系統(tǒng)的運行速度。

而統(tǒng)一的管理和調(diào)度，可以合理分配內(nèi)部資源，根據(jù)系統(tǒng)的當(dāng)前情況調(diào)整線程的數(shù)量。

那總結(jié)來說有以下 3 個好處：

1. 降低資源消耗：通過重復(fù)利用現(xiàn)有的線程來執(zhí)行任務(wù)，避免多次創(chuàng)建和銷毀線程。
2. 提高相應(yīng)速度：因為省去了創(chuàng)建線程這個步驟，所以在拿到任務(wù)時，可以立刻開始執(zhí)行。
3. 提供附加功能：線程池的可拓展性使得我們可以自己加入新的功能，比如說定時、延時來執(zhí)行某些線程。

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

線程池的實現(xiàn)

Java 給我們提供了 Executor 接口來使用線程池。

Executor

我們常用的線程池有這兩大類：

• ThreadPoolExecutor
• ScheduledThreadPoolExecutor

它倆的區(qū)別呢，就是第一個是普通的，第二個是可以定時執(zhí)行的。

當(dāng)然還有其他線程池，比如 JDK 1.7 才出現(xiàn)的 ForkJoinPool ，可以把大任務(wù)分割成小任務(wù)來執(zhí)行，最后再大一統(tǒng)。

那么任務(wù)提交到一個線程池之后，它會經(jīng)歷一個怎樣的過程呢?

執(zhí)行過程

線程池在內(nèi)部實際上采用了生產(chǎn)者消費者模型(還不清楚這個模型的在文章開頭有改文章的鏈接)將線程和任務(wù)解藕，從而使線程池同時管理任務(wù)和線程。

當(dāng)任務(wù)提交到線程池里之后，需要經(jīng)過以下流程：

執(zhí)行過程

1. 首先它檢查核心線程池是否已滿。這個核心線程池，就是不管用戶量多少線程池始終維護的線程的池子。比如說線程池的總?cè)萘孔疃嗄苎b 100 個線程，核心線程池我們設(shè)置為 50，那么就無論用戶量有多少，都保持 50 個線程活著。這個數(shù)字當(dāng)然是根據(jù)具體的業(yè)務(wù)需求來決定的。
2. 阻塞隊列，就是 BlockingQueue ，在生產(chǎn)者消費者這節(jié)里提到過。
3. 最后判斷線程池是否已滿，就是判斷是不是已經(jīng)有 100 個線程了，而不是 50 個。
4. 如果已經(jīng)滿了，所以不能繼續(xù)創(chuàng)建線程了，就需要按照飽和策略或者叫做拒絕策略來處理。這個飽和策略我們下文再講。

ThreadPoolExecutor

我們主要說下 ThreadPoolExecutor ，它是最常用的線程池。

ThreadPoolExecutor Structure

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

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

這里我們來仔細看下這幾個參數(shù)：

1.corePoolSize：這個就是上文提到過的核心線程池的大小，在核心里的線程是永遠不會失業(yè)的。

• 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：存活時間。這個時間指的是，當(dāng)線程池中的線程數(shù)量大于核心線程數(shù)，這些線程閑著之后，多久銷毀它們。

• 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：對應(yīng)上面存活時間的時間單位。

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

5.workQueue：這是一個阻塞隊列，其實線程池也是生產(chǎn)者消費者模型的一種，任務(wù) - 相當(dāng)于生產(chǎn)者，線程 - 相當(dāng)于消費者，所以這個阻塞隊列是用來協(xié)調(diào)生產(chǎn)和消費的進度的。

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

6.threadFactory：這里用到了工程模式，用來創(chuàng)建線程的。

• 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 個參數(shù)構(gòu)造線程池，當(dāng)然了，貼心的 Java 也給我們包裝好了幾類線程池可以很方便的拿來使用。

• newCachedThreadPool
• newFixedThreadPool
• newSingleThreadExecutor

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

newCachedThreadPool

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

這里我們可以看到，

• 核心線程池數(shù)量為 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) { 
        // 創(chuàng)建一個線程池 
        ExecutorService executorService = Executors.newCachedThreadPool(); 
        // 向線程池提交任務(wù) 
        for (int i = 0; i < 50; i++) { 
            executorService.execute(new Task());//線程池執(zhí)行任務(wù) 
        } 
        executorService.shutdown(); 
    } 
} 

執(zhí)行結(jié)果：

newCached 結(jié)果

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

newFixedThreadPool

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

這個線程池的特點是：

1. 線程池中的線程數(shù)量是固定的，也是我們創(chuàng)建線程池時需要穿入的參數(shù);
2. 超出這個數(shù)量的線程就需要在隊列中等待。

它的適用場景是：

• 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 結(jié)果

這里我限制了線程池里最多有 10 個線程，哪怕有 200 個任務(wù)需要執(zhí)行，也只有 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 結(jié)果

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

小結(jié)

所以在使用線程池時，其實都是調(diào)用的 ThreadPoolExecutor 這個類，只不過傳遞的不同參數(shù)。

這里要特別注意兩個參數(shù)：

• 一是 workQueue 的選擇，這個就是阻塞隊列的選擇，如果要說還得這么一大篇文章，之后有機會再寫吧。
• 二是 handler 的設(shè)置。

那我們發(fā)現(xiàn)，在上面的 3 個具體線程池里，其實都沒有設(shè)定 handler，這是因為它們都使用了 defaultHandler。

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

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

1. AbortPolicy 表示拒絕任務(wù)并拋出一個異常 RejectedExecutionException。這個我稱之為“正式拒絕”，比如你面完了最后一輪面試，最終接到 HR 的拒信。
2. DiscardPolicy 拒絕任務(wù)但不吭聲。這個就是“默拒”，比如大部分公司拒簡歷的時候都是默拒。
3. DiscardOldestPolicy 顧名思義，就是把老的任務(wù)丟掉，執(zhí)行新任務(wù)。
4. CallerRunsPolicy 直接調(diào)用線程處理該任務(wù)，就是 VIP 嘛。

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

好了以上就是本文的所有內(nèi)容了。當(dāng)然線程池還有很多知識點，比如 execute() 和 submit() 方法，線程池的生命周期等等。

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

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

本文轉(zhuǎn)載自微信公眾號「碼農(nóng)田小齊」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系碼農(nóng)田小齊公眾號。