Java中線程池，你真的會用嗎？

在《深刻源碼分析Java線程池的實現原理》這篇文章中，咱們介紹過了Java中線程池的常見用法以及基本原理。

在文中有這樣一段描述：

能夠經過Executors靜態工廠構建線程池，但通常不建議這樣使用。

關於這個問題，在那篇文章中並無深刻的展開。做者之因此這麼說，是由於這種建立線程池的方式有很大的隱患，稍有不慎就有可能致使線上故障，如：一次Java線程池誤用引起的血案和總結（ zhuanlan.zhihu.com/p/32867181 ）

本文咱們就來圍繞這個問題來分析一下爲何JDK自身提供的構建線程池的方式並不建議使用？到底應該如何建立一個線程池呢？

Executors

Executors 是一個Java中的工具類。提供工廠方法來建立不一樣類型的線程池。



從上圖中也能夠看出，Executors的建立線程池的方法，建立出來的線程池都實現了ExecutorService接口。經常使用方法有如下幾個：

newFiexedThreadPool(int Threads)：建立固定數目線程的線程池。

newCachedThreadPool()：建立一個可緩存的線程池，調用execute 將重用之前構造的線程（若是線程可用）。若是沒有可用的線程，則建立一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鐘未被使用的線程。

newSingleThreadExecutor()建立一個單線程化的Executor。

newScheduledThreadPool(int corePoolSize)建立一個支持定時及週期性的任務執行的線程池，多數狀況下可用來替代Timer類。

類看起來功能仍是比較強大的，又用到了工廠模式、又有比較強的擴展性，重要的是用起來還比較方便，如：

ExecutorService executor = Executors.newFixedThreadPool(nThreads) ;
複製代碼

便可建立一個固定大小的線程池。

可是爲何我說不建議你們使用這個類來建立線程池呢？

我提到的是『不建議』，可是在阿里巴巴Java開發手冊中也明確指出，並且用的詞是『不容許』使用Executors建立線程池。


Executors存在什麼問題

在阿里巴巴Java開發手冊中提到，使用Executors建立線程池可能會致使OOM(OutOfMemory ,內存溢出)，可是並無說明爲何，那麼接下來咱們就來看一下到底爲何不容許使用Executors？

咱們先來一個簡單的例子，模擬一下使用Executors致使OOM的狀況。

/**
 * @author Hollis
 */
public class ExecutorsDemo {
    private static ExecutorService executor = Executors.newFixedThreadPool(15);
    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            executor.execute(new SubThread());
        }
    }
}

class SubThread implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            //do nothing
        }
    }
}
複製代碼

經過指定JVM參數：-Xmx8m -Xms8m 運行以上代碼，會拋出OOM:

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
    at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
    at com.hollis.ExecutorsDemo.main(ExecutorsDemo.java:16)
複製代碼

以上代碼指出，ExecutorsDemo.java的第16行，就是代碼中的executor.execute(new SubThread());。

Executors爲何存在缺陷

經過上面的例子，咱們知道了Executors建立的線程池存在OOM的風險，那麼究竟是什麼緣由致使的呢？咱們須要深刻Executors的源碼來分析一下。

其實，在上面的報錯信息中，咱們是能夠看出蛛絲馬跡的，在以上的代碼中其實已經說了，真正的致使OOM的實際上是LinkedBlockingQueue.offer方法。

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
    at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
    at com.hollis.ExecutorsDemo.main(ExecutorsDemo.java:16)
複製代碼

若是讀者翻看代碼的話，也能夠發現，其實底層確實是經過LinkedBlockingQueue實現的：

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

若是讀者對Java中的阻塞隊列有所瞭解的話，看到這裏或許就可以明白緣由了。

Java中的BlockingQueue主要有兩種實現，分別是ArrayBlockingQueue 和 LinkedBlockingQueue。

ArrayBlockingQueue是一個用數組實現的有界阻塞隊列，必須設置容量。

LinkedBlockingQueue是一個用鏈表實現的有界阻塞隊列，容量能夠選擇進行設置，不設置的話，將是一個無邊界的阻塞隊列，最大長度爲Integer.MAX_VALUE。

這裏的問題就出在：**不設置的話，將是一個無邊界的阻塞隊列，最大長度爲Integer.MAX_VALUE。**也就是說，若是咱們不設置LinkedBlockingQueue的容量的話，其默認容量將會是Integer.MAX_VALUE。

而newFixedThreadPool中建立LinkedBlockingQueue時，並未指定容量。此時，LinkedBlockingQueue就是一個無邊界隊列，對於一個無邊界隊列來講，是能夠不斷的向隊列中加入任務的，這種狀況下就有可能由於任務過多而致使內存溢出問題。

上面提到的問題主要體如今newFixedThreadPool和newSingleThreadExecutor兩個工廠方法上，並非說newCachedThreadPool和newScheduledThreadPool這兩個方法就安全了，這兩種方式建立的最大線程數多是Integer.MAX_VALUE，而建立這麼多線程，必然就有可能致使OOM。

建立線程池的正確姿式

避免使用Executors建立線程池，主要是避免使用其中的默認實現，那麼咱們能夠本身直接調用ThreadPoolExecutor的構造函數來本身建立線程池。在建立的同時，給BlockQueue指定容量就能夠了。

private static ExecutorService executor = new ThreadPoolExecutor(10, 10,
        60L, TimeUnit.SECONDS,
        new ArrayBlockingQueue(10));
複製代碼

這種狀況下，一旦提交的線程數超過當前可用線程數時，就會拋出java.util.concurrent.RejectedExecutionException，這是由於當前線程池使用的隊列是有邊界隊列，隊列已經滿了便沒法繼續處理新的請求。可是異常（Exception）總比發生錯誤（Error）要好。

除了本身定義ThreadPoolExecutor外。還有其餘方法。這個時候第一時間就應該想到開源類庫，如apache和guava等。

做者推薦使用guava提供的ThreadFactoryBuilder來建立線程池。

public class ExecutorsDemo {

    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    private static ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {

        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            pool.execute(new SubThread());
        }
    }
}
複製代碼

經過上述方式建立線程時，不只能夠避免OOM的問題，還能夠自定義線程名稱，更加方便的出錯的時候溯源。

思考題，文中做者說：發生異常（Exception）要比發生錯誤（Error）好，爲何這麼說？

文中提到的《阿里巴巴Java開發手冊》，請關注公衆號Hollis，回覆：手冊。便可得到完整版PDF。