今天我們來聊一下這個 Java 中的線程池，線程池，這塊的內(nèi)容，已經(jīng)是非常的容易被面試官問到的內(nèi)容，為什么呢？這是因為線程池，是一種多線程的處理方式，如果使用方式得當(dāng)?shù)脑?，那么對我們的代碼的質(zhì)量也是非常高的。

我們既然要了解線程池，那么肯定是需要從幾個角度來考慮，第一，什么是線程池？第二：為什么需要線程池？第三，線程池的創(chuàng)建方式都有哪些。

什么是線程池

線程池是一種多線程處理形式，處理過程中將任務(wù)添加到隊列，然后在創(chuàng)建線程后自動啟動這些任務(wù)。

線程池線程都是后臺線程。每個線程都使用默認(rèn)的堆棧大小，以默認(rèn)的優(yōu)先級運(yùn)行，并處于多線程單元 中。如果某個線程在托管代碼中空閑（如正在等待某個事件），則線程池將插入另一個輔助線程來使所 有處理器保持繁忙。

如果所有線程池線程都始終保持繁忙，但隊列中包含掛起的工作，則線程池將在一段時間后創(chuàng)建另一個輔助線程但線程的數(shù)目永遠(yuǎn)不會超過最大值。超過最大值的線程可以排隊，但他們要等到其他線程完成后才啟動。

為什么需要線程池

我們有兩種常見的創(chuàng)建線程的方法，

• 一種是繼承Thread類，
• 一種是實現(xiàn)Runnable的接口，Thread類其實也是實現(xiàn)了Runnable接口。

但是我們創(chuàng)建這兩種線程在運(yùn)行結(jié)束后都會被虛擬機(jī)銷毀，如果線程數(shù)量多的話，頻繁的創(chuàng)建和銷毀線程會大大浪費(fèi)時間和效率，更重要的是浪費(fèi)內(nèi)存。那么有沒有一種方法能讓線程運(yùn)行完后不立即銷毀，而是讓線程重復(fù)使用，繼續(xù)執(zhí)行其他的任務(wù)哪？

這就是線程池的由來，很好的解決線程的重復(fù)利用，避免重復(fù)開銷。

線程池的優(yōu)點都有哪些？

(1)重用存在的線程，減少對象創(chuàng)建銷毀的開銷。

(2)可有效的控制最大并發(fā)線程數(shù)，提高系統(tǒng)資源的使用率，同時避免過多資源競爭，避免堵塞。

(3)提供定時執(zhí)行、定期執(zhí)行、單線程、并發(fā)數(shù)控制等功能。

而且優(yōu)點這么多，那么肯定就得知道 Java 提供了哪些線程池的實現(xiàn)方式了。

Java 提供了哪幾種線程池

種類一

FixedThreadPool

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

newFixedThreadPool 實際上返回的是 ThreadPoolExecutor，ThreadPoolExecutor 實際就是線程池實現(xiàn)類，使用了典型的模板方法設(shè)計模式，通過ThreadPoolExecutor構(gòu)造器的說明我們稍微解釋一下各參數(shù)的意思：

構(gòu)造器如下：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

• corePoolSize 核心線程數(shù)，線程池一直存在的線程（即使這些線程是空閑的），除非你設(shè)置allowCoreThreadTimeOut
• maximumPoolSize 線程池中允許存在的最多的線程數(shù)，當(dāng)workQueue滿了之后會創(chuàng)建線程直到數(shù)量達(dá)到maximumPoolSize
• keepAliveTime 當(dāng)線程池中的線程數(shù)超過核心線程數(shù)，超過部分的線程可以空閑keepAliveTime時間，如果這段時間還沒有任務(wù)過來則超過部分線程就會銷毀
• unit keepAliveTime的單位
• workQueue 等待隊列，當(dāng)corePoolSize線程都在處理任務(wù)時，新進(jìn)入線程池的任務(wù)則翻入等待下隊列
• threadFactory 創(chuàng)建線程池中線程的線程工廠
• handler 拒絕策略 當(dāng)線程池已達(dá)到最大線程數(shù)和等待隊列也已經(jīng)滿了，則使用拒絕策略

而newFixedThreadPool使用了corePoolSize和maximumPoolSize相等，所以當(dāng)線程池線程數(shù)到達(dá)corePoolSize之后就不會再創(chuàng)建線程。

并且newFixedThreadPool使用了LinkedBlockingQueue，而且使用的是默認(rèn)構(gòu)造器，容量是Integer.MAX_VALUE，keepAliveTime是0，實際上設(shè)不設(shè)置都沒關(guān)系，因為不會超過核心線程數(shù)。

實際上我們也可以理解為FixedThreadPool該線程池中的線程數(shù)量始不變。當(dāng)有一個新的任務(wù)提交時，線程池中若有空閑線程，則立即執(zhí)行。若沒有，則新的任務(wù)會被暫存在一個任務(wù)隊列中，待有線程空閑時，便處理在任務(wù)隊列中的任務(wù)。

種類二

SingleThreadExecutor

實際上SingleThreadExecutor是使用單個 worker 線程的Executor。

也就是說方法返回一個只有一個線程的線程池。若多余一個任務(wù)被提交到該線程 池，任務(wù)會被保存在一個任務(wù)隊列中，待線程空閑，按先入先出的順序執(zhí)行隊列中的任務(wù)

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

SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 被設(shè)置為 1 。其他參數(shù)與 FixedThreadPool 相同。 SingleThreadExecutor 使用無 隊列 LinkedBlockingQueue 作 為線程池的工作隊列（ 隊列的容量為Integer.MAX_VALUE ）。

種類三

CachedThreadPool

該方法返回一個可根據(jù)實際情況調(diào)整線程數(shù)量的線程池。線程池的線程數(shù) 量不確定，但若有空閑線程可以復(fù)用，則會優(yōu)先使用可復(fù)用的線程。若所有線程均在工作，又有新 的任務(wù)提交，則會創(chuàng)建新的線程處理任務(wù)。所有線程在當(dāng)前任務(wù)執(zhí)行完畢后，將返回線程池進(jìn)行復(fù) 用。

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

• 這個線程池corePoolSize是0，maximumPoolSize是Integer.MAX_VALUE，根據(jù)我們之前對源碼的分析，CachedThreadPool不會有核心線程，核心線程數(shù)的addworker方法不會執(zhí)行，直接嘗試加入queue中。
• keepAliveTime是60s，也就是60s從隊列中沒有拿到任務(wù)，worker就會自動銷毀。
• queue使用的是SynchronousQueue，這個就是CachedThreadPool實現(xiàn)不停創(chuàng)建工作線程的關(guān)鍵，因為線程池處理任務(wù)分為三步：有任務(wù)過來先創(chuàng)建核心線程，當(dāng)線程數(shù)達(dá)到核心線程數(shù)時則會進(jìn)入等待隊列，當(dāng)?shù)却犃袧M了則再創(chuàng)建非核心線程，直到線程數(shù)達(dá)到最大線程數(shù)后執(zhí)行拒絕策略，所以可以猜測SynchronousQueue應(yīng)該是沒有容量的隊列，放入一個offer操作必須有一個poll操作在等待，沒有的話就執(zhí)行入隊失敗，然后創(chuàng)建非核心線程進(jìn)行處理
• 線程工廠和拒絕策略都沒有指定，則使用的就是默認(rèn)的，默認(rèn)的拒絕策略是丟出一個異常

種類四

ScheduledThreadPoolExecutor

這個線程池的構(gòu)造器就比較多了

// 第一個構(gòu)造函數(shù)
   public ScheduledThreadPoolExecutor(int corePoolSize) {
       super(corePoolSize, Integer.MAX_VALUE,
             DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
             new DelayedWorkQueue());
   }

   // 第二個構(gòu)造函數(shù)
   public ScheduledThreadPoolExecutor(int corePoolSize,
                                      ThreadFactory threadFactory) {
       super(corePoolSize, Integer.MAX_VALUE,
             DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
             new DelayedWorkQueue(), threadFactory);
   }

   // 第三個構(gòu)造函數(shù)
   public ScheduledThreadPoolExecutor(int corePoolSize,
                                      RejectedExecutionHandler handler) {
       super(corePoolSize, Integer.MAX_VALUE,
             DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
             new DelayedWorkQueue(), handler);
   }

   // 第四個構(gòu)造函數(shù)
   public ScheduledThreadPoolExecutor(int corePoolSize,
                                      ThreadFactory threadFactory,
                                      RejectedExecutionHandler handler) {
       super(corePoolSize, Integer.MAX_VALUE,
             DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
             new DelayedWorkQueue(), threadFactory, handler);
   }

主要用來在給定的延遲后運(yùn)行任務(wù)，或者定期執(zhí)行任務(wù)。ScheduledThreadPoolExecutor又分為：ScheduledThreadPoolExecutor（包含多個線程）和SingleThreadScheduledExecutor （只包含一個線程）兩種。

線程池的創(chuàng)建方式

其實創(chuàng)建方式，就是Executors，使用 Executors 可以非常輕易的創(chuàng)建我們上面所說的這幾種線程池。但是呢，有一個地方不知道大家有沒有注意到，在 阿里的開發(fā)手冊上面，是不允許使用 Executors 去創(chuàng)建的，更推薦我們使用的是 ThreadPoolExecutor 構(gòu)造去創(chuàng)建，這樣的好處就是為了規(guī)避資源耗盡的風(fēng)險那時候拋出的就不是異常，而是錯誤了。

使用ThreadPoolExecutor的構(gòu)造函數(shù)創(chuàng)建

private static ExecutorService executor = new ThreadPoolExecutor(13, 13,
60L, TimeUnit.SECONDS,
new ArrayBlockingQueue(13));

我們可以自己直接調(diào)用 ThreadPoolExecutor 的構(gòu)造函數(shù)來自己創(chuàng)建線程池。在創(chuàng)建的同時，給 BlockQueue 指定容量就可以了。

這時候如果提交的線程數(shù)超過了可用線程數(shù)的時候，就會拋出異常，比如 java.util.concurrent.RejectedExecutionException,這是因為當(dāng)前線程池使用的隊列是有邊界隊列，隊列已經(jīng)滿了便無法繼續(xù)處理新的請求。

如果你覺得對 Error 和 Exception 沒有任何感覺得話，你也是可以使用 Executors 去創(chuàng)建的。

你還知道有其他方式去創(chuàng)建線程池的么？