線程池是用來統一管理線程的，在 Java 中創建和銷毀線程都是一件消耗資源的事情，線程池可以重復使用線程，不再頻繁的創建、銷毀線程。

初識

Java 中的線程池是由 juc 即 java.util.concurrent 包來實現的，最主要的就是 ThreadPoolExecutor 類。

1. Executor: 代表線程池的接口，有一個 execute() 方法，給一個 Runnable 類型對象就可以分配一個線程執行。
2. ExecutorService：是 Executor 的子接口，提供了線程池的一些生命周期方法。代表了一個線程池管理器。
3. ThreadPoolExecutor：一個線程池的實現類，可以通過調用 Executors 靜態工廠方法來創建線程池并返回一個 ExecutorService 對象。

ThredadPoolExcutor

看一下最常用的 ThredadPoolExcutor ,下圖是 ThreadPoolExecutor 的構造函數

從源碼中可以看出每個前三個構造函數都調用了最后一個構造函數。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue< Runnable > workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
    //省略代碼
    }

仔細分析一下構造參數：

1. corePoolSize：線程池里的核心線程數量，當正在運行的線程數量小于核心線程數量，就創建一個核心線程。
2. maximumPoolSize：線程池最多能放多少個線程。
3. keepAliveTime：線程的閑置時間，當線程池里面的線程數量大于 corePoolSize 的時候，多出來的線程在等待的時間之后會被釋放掉
4. unit：keepAliveTime 的單位
5. workQueue：一個阻塞隊列。
6. threadFactory：通過這個工廠模式創建線程。
7. handler：處理線程隊列滿了報錯的。

結合線程池的參數簡單的畫出線程池的工作模型。

當線程池中的核心線程數量 corePoolSize 滿了，就會將任務先加入到任務隊列 workQueue 中。

執行過程

線程池的執行過程如下圖：

1. 首先判斷核心線程 corePoolSize 是不是滿了，如果沒有滿，就執行任務，否則就進入下一步。
2. 線程池判斷任務隊列 workQueue 是否了，如果沒有滿，則將新提交的任務放入在這個任務隊列里。如果任務隊列滿了，則進入一步。
3. 判斷線程池里的線程達到了最大線程數 maximumPoolSize，如果沒有，則創建一個新的線程來執行任務。如果已經滿了，則交給拒絕策略來處理這個任務。

常用的線程池

線程池的創建需要有 7 個參數，還是比較復雜的，JVM 為我們提供了 Executors 類中多個靜態工廠，生成一些常用的線程池。

SingleThreadExecutor

單線程的線程池，里面就一個核心線程數。

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

ThreadPoolExecutor 參數只有一個核心線程數和一個最大線程數，這個很少用到。它保證了所有線程的執行順序都是按照提交到線程池的順序執行。

public class TodoDemo implements Runnable {


    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for(int i = 0; i < 10; i++) {
            executorService.execute(new TodoDemo());
        }
        executorService.shutdown();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Running");
    }
}

只有一個線程在跑。

FixedThreadExecutor

固定數量的線程池

return new ThreadPoolExecutor(nThreads, nThreads,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue< Runnable >());
}

這個線程池的特點就是線程的數量是固定的，超過這個數量的任務就得在 LinkedBlockingQueue 中排隊等候。

public class TodoDemo implements Runnable {
    
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for(int i = 0; i < 10; i++) {
            executorService.execute(new TodoDemo());
        }
        executorService.shutdown();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Running");
    }
}

可以看到就算提交 100 個任務也只有 3 個線程。

CachedThreadExecutor

自動回收空閑的線程

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

可以看到核心線程數量為 0， 表示不會永久保留任何的線程，最大線程的數量是 Integer.MAX_VALUE，可以無限制的創建線程，但是當有大量線程處于空閑狀態的時候，超過 60s 就會被銷毀。

public class TodoDemo implements Runnable {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i = 0; i < 20; i++) {
            executorService.execute(new TodoDemo());
        }
        executorService.shutdown();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Running");
    }
}

雖然這個線程池可以想建多少個線程就建多少個線程，但是還是會重用已經完成任務的線程。

一般最常用的是FixedThreadExecutor和CachedThreadExecutor。

線程池的回收策略

在線程池中任務隊列已經滿了，并且線程的數量已經到了最大的數量，這個時候再加任務線程池就不再接受了。

在 ThreadPoolExecutor 里有 4 種拒絕策略，都實現了 RejectedExecutionHandler：

1. AbortPolicy 表示拋出一個異常。
2. DiscardPolicy 拒絕任務但是不提示。
3. DiscardOldestPolicy 丟棄掉老的任務，執行新的任務。
4. CallerRunsPolicy 直接調用線程處理。

總結

線程池的作用是提高系統的性能和線程的利用率，不再需要頻繁的創建和銷毀線程。如果使用最簡單的方式創建線程，在用戶量巨大的情況下，消耗的性能是非常恐怖的，所以才有了線程池。