新手一看就懂的線程池
那相信大家也能感受到，其實用多線程是很麻煩的，包括線程的創(chuàng)建、銷毀和調(diào)度等等，而且我們平時工作時好像也并沒有這樣來 new 一個線程，其實是因為很多框架的底層都用到了線程池。
線程池是幫助我們管理線程的工具，它維護了多個線程，可以降低資源的消耗，提高系統(tǒng)的性能。
并且通過使用線程池，我們開發(fā)人員可以更好的把精力放在任務(wù)代碼上，而不去管線程是如何執(zhí)行的，實現(xiàn)任務(wù)提交和執(zhí)行的解藕。
本文將從是何、為何、如何的角度來講解線程池：
- 線程池是什么
- 為什么要用線程池
- 怎么用線程池
線程池 Thread Pool
線程池是一種池化的技術(shù)，類似的還有數(shù)據(jù)庫連接池、HTTP 連接池等等。
池化的思想主要是為了減少每次獲取和結(jié)束資源的消耗，提高對資源的利用率。
比如在一些偏遠(yuǎn)地區(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 個好處：
- 降低資源消耗：通過重復(fù)利用現(xiàn)有的線程來執(zhí)行任務(wù)，避免多次創(chuàng)建和銷毀線程。
- 提高相應(yīng)速度：因為省去了創(chuàng)建線程這個步驟，所以在拿到任務(wù)時，可以立刻開始執(zhí)行。
- 提供附加功能：線程池的可拓展性使得我們可以自己加入新的功能，比如說定時、延時來執(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í)行過程
- 首先它檢查核心線程池是否已滿。這個核心線程池，就是不管用戶量多少線程池始終維護的線程的池子。比如說線程池的總?cè)萘孔疃嗄苎b 100 個線程，核心線程池我們設(shè)置為 50，那么就無論用戶量有多少，都保持 50 個線程活著。這個數(shù)字當(dāng)然是根據(jù)具體的業(yè)務(wù)需求來決定的。
- 阻塞隊列，就是 BlockingQueue ，在生產(chǎn)者消費者這節(jié)里提到過。
- 最后判斷線程池是否已滿，就是判斷是不是已經(jīng)有 100 個線程了，而不是 50 個。
- 如果已經(jīng)滿了，所以不能繼續(xù)創(chuàng)建線程了，就需要按照飽和策略或者叫做拒絕策略來處理。這個飽和策略我們下文再講。
ThreadPoolExecutor
我們主要說下 ThreadPoolExecutor ，它是最常用的線程池。
ThreadPoolExecutor Structure
這里我們可以看到，這個類里有 4 個構(gòu)造方法，點進去仔細(xì)看，其實前三個都 call 了最后一個，所以我們只需要看最后一個就好。
- public ThreadPoolExecutor(int corePoolSize,
- int maximumPoolSize,
- long keepAliveTime,
- TimeUnit unit,
- BlockingQueue<Runnable> workQueue,
- ThreadFactory threadFactory,
- RejectedExecutionHandler handler) {
- ...
- }
這里我們來仔細(xì)看下這幾個參數(shù)：
1.corePoolSize：這個就是上文提到過的核心線程池的大小，在核心里的線程是永遠(yuǎn)不會失業(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>());
- }
這個線程池的特點是：
- 線程池中的線程數(shù)量是固定的，也是我們創(chuàng)建線程池時需要穿入的參數(shù);
- 超出這個數(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：
- AbortPolicy 表示拒絕任務(wù)并拋出一個異常 RejectedExecutionException。這個我稱之為“正式拒絕”，比如你面完了最后一輪面試，最終接到 HR 的拒信。
- DiscardPolicy 拒絕任務(wù)但不吭聲。這個就是“默拒”，比如大部分公司拒簡歷的時候都是默拒。
- DiscardOldestPolicy 顧名思義，就是把老的任務(wù)丟掉，執(zhí)行新任務(wù)。
- CallerRunsPolicy 直接調(diào)用線程處理該任務(wù)，就是 VIP 嘛。
所以這 3 種線程池都使用的默認(rèn)策略也就是第一種，光明正大的拒絕。
好了以上就是本文的所有內(nèi)容了。當(dāng)然線程池還有很多知識點，比如 execute() 和 submit() 方法，線程池的生命周期等等。
但隨著閱讀量的逐漸走低，齊姐意識到了這似乎有什么誤會，所以這篇文章是多線程系列的最后一篇了。
本文已收錄至我的 Github 上：https://github.com/xiaoqi6666/NYCSDE，點擊閱讀原文直達(dá)，這個 Github 匯總了我所有的文章和資料，之后也會一直更新和維護，還希望大家?guī)兔c個 Star，你們的支持和認(rèn)可，就是我創(chuàng)作的最大動力!
本文轉(zhuǎn)載自微信公眾號「碼農(nóng)田小齊」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系碼農(nóng)田小齊公眾號。
