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

初識

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

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

ThredadPoolExcutor

看一下最常用的 ThredadPoolExcutor ,下圖是 ThreadPoolExecutor 的構(gòu)造函數(shù)

從源碼中可以看出每個前三個構(gòu)造函數(shù)都調(diào)用了最后一個構(gòu)造函數(shù)。

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

仔細分析一下構(gòu)造參數(shù)：

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

結(jié)合線程池的參數(shù)簡單的畫出線程池的工作模型。

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

執(zhí)行過程

線程池的執(zhí)行過程如下圖：

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

常用的線程池

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

SingleThreadExecutor

單線程的線程池，里面就一個核心線程數(shù)。

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

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

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

固定數(shù)量的線程池

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

這個線程池的特點就是線程的數(shù)量是固定的，超過這個數(shù)量的任務就得在 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 >());
}

可以看到核心線程數(shù)量為 0， 表示不會永久保留任何的線程，最大線程的數(shù)量是 Integer.MAX_VALUE，可以無限制的創(chuàng)建線程，但是當有大量線程處于空閑狀態(tài)的時候，超過 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");
    }
}

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

一般最常用的是FixedThreadExecutor和CachedThreadExecutor。

線程池的回收策略

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

在 ThreadPoolExecutor 里有 4 種拒絕策略，都實現(xiàn)了 RejectedExecutionHandler：

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

總結(jié)

線程池的作用是提高系統(tǒng)的性能和線程的利用率，不再需要頻繁的創(chuàng)建和銷毀線程。如果使用最簡單的方式創(chuàng)建線程，在用戶量巨大的情況下，消耗的性能是非?？植赖模圆庞辛司€程池。