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

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

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

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

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

線程池 Thread Pool

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

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

比如在一些偏遠地區(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)一的管理和調度，可以合理分配內部資源，根據(jù)系統(tǒng)的當前情況調整線程的數(shù)量。

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

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

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

線程池的實現(xiàn)

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

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

• ThreadPoolExecutor
• ScheduledThreadPoolExecutor

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

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

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

執(zhí)行過程

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

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

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

ThreadPoolExecutor

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

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

public?ThreadPoolExecutor(int?corePoolSize,
??????????????????????????int?maximumPoolSize,
??????????????????????????long?keepAliveTime,
??????????????????????????TimeUnit?unit,
??????????????????????????BlockingQueue?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：存活時間。這個時間指的是，當線程池中的線程數(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：對應上面存活時間的時間單位。

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

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

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ù)構造線程池，當然了，貼心的 Java 也給我們包裝好了幾類線程池可以很方便的拿來使用。

• newCachedThreadPool
• newFixedThreadPool
• newSingleThreadExecutor

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

newCachedThreadPool

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

這里我們可以看到，

• 核心線程池數(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();
????????//?向線程池提交任務
????????for?(int?i?=?0;?i?50;?i++)?{
????????????executorService.execute(new?Task());//線程池執(zhí)行任務
????????}
????????executorService.shutdown();
????}
}

執(zhí)行結果：

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

newFixedThreadPool

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

這個線程池的特點是：

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

這里我限制了線程池里最多有 10 個線程，哪怕有 200 個任務需要執(zhí)行，也只有 1-10 這 10 個線程可以運行。

newSingleThreadExecutor

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

這個線程池顧名思義，里面只有 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 這個類，只不過傳遞的不同參數(shù)。

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

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

那我們發(fā)現(xiàn)，在上面的 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 顧名思義，就是把老的任務丟掉，執(zhí)行新任務。
4. CallerRunsPolicy 直接調用線程處理該任務，就是 VIP 嘛。

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

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

特別推薦一個分享架構+算法的優(yōu)質內容，還沒關注的小伙伴，可以長按關注一下：

長按訂閱更多精彩▼
如有收獲，點個在看，誠摯感謝