我們都知道在面試的過(guò)程中，關(guān)于線程池的問(wèn)題，一直都是面試官比較注重的考點(diǎn)，現(xiàn)在也不會(huì)有面試官會(huì)選擇去問(wèn)創(chuàng)建線程都有哪些方式了，而更多的實(shí)惠關(guān)注到如何去使用線程池，今天了不起就來(lái)和大家說(shuō)說(shuō)線程池。

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

在Java中，創(chuàng)建線程池主要使用java.util.concurrent包下的Executors類。這個(gè)類提供了幾種靜態(tài)工廠方法，用于創(chuàng)建和管理不同類型的線程池。以下是一些常見(jiàn)的創(chuàng)建線程池的方式：

1.Fixed Thread Pool（固定線程池）

• 創(chuàng)建一個(gè)可重用固定線程數(shù)的線程池，以共享的無(wú)界隊(duì)列方式來(lái)運(yùn)行這些線程。在任意點(diǎn)，在大多數(shù) nThreads 線程會(huì)處于處理任務(wù)的活動(dòng)狀態(tài)。如果在所有線程處于活動(dòng)狀態(tài)時(shí)提交附加任務(wù)，則在有可用線程之前，附加任務(wù)將在隊(duì)列中等待。
• 創(chuàng)建方法：Executors.newFixedThreadPool(int nThreads)

2.Cached Thread Pool（緩存線程池）

• 創(chuàng)建一個(gè)可根據(jù)需要?jiǎng)?chuàng)建新線程的線程池，但是在以前構(gòu)造的線程可用時(shí)將重用它們。對(duì)于執(zhí)行很多短期異步任務(wù)的程序而言，這些線程池通常可提高程序性能。調(diào)用 execute 將重用以前構(gòu)造的線程（如果線程可用）。如果現(xiàn)有線程沒(méi)有可用的，則創(chuàng)建一個(gè)新線程并添加到池中。終止并從緩存中移除那些已有 60 秒鐘未被使用的線程。
• 創(chuàng)建方法：Executors.newCachedThreadPool()

3.Single Thread Executor（單線程執(zhí)行器）

• 創(chuàng)建一個(gè)使用單個(gè)工作線程的 Executor，以無(wú)界隊(duì)列方式來(lái)運(yùn)行該線程。（注意，如果單個(gè)線程始終因?yàn)榈却氯蝿?wù)而處于非活動(dòng)狀態(tài)，則在現(xiàn)行線程終止之前，它可能無(wú)法終止。）但是，如果線程因?yàn)槭《K止，那么會(huì)有一個(gè)新的線程來(lái)替代它。單個(gè)線程的優(yōu)勢(shì)在于，你無(wú)需處理對(duì)線程生命周期的管理。
• 創(chuàng)建方法：Executors.newSingleThreadExecutor()

4.Scheduled Thread Pool（計(jì)劃線程池）

• 創(chuàng)建一個(gè)線程池，它可安排在給定延遲后運(yùn)行命令或者定期地執(zhí)行。
• 創(chuàng)建方法：Executors.newScheduledThreadPool(int corePoolSize)

5.自定義線程池

除了使用Executors類提供的靜態(tài)工廠方法創(chuàng)建線程池外，還可以通過(guò)實(shí)例化ThreadPoolExecutor類來(lái)自定義線程池。這種方式提供了更多的靈活性，允許你設(shè)置線程池的核心參數(shù)，如核心線程數(shù)、最大線程數(shù)、線程存活時(shí)間、任務(wù)隊(duì)列等。

示例代碼：

import java.util.concurrent.*;  
  
public class CustomThreadPool {  
    public static void main(String[] args) {  
        int corePoolSize = 5;  
        int maximumPoolSize = 10;  
        long keepAliveTime = 60L;  
        TimeUnit unit = TimeUnit.SECONDS;  
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();  
        ThreadFactory threadFactory = Executors.defaultThreadFactory();  
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();  
  
        ThreadPoolExecutor executor = new ThreadPoolExecutor(  
                corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);  
  
        // 使用線程池執(zhí)行任務(wù)...  
    }  
}

非自定義線程池的缺點(diǎn)

我們先來(lái)看看 Executors 當(dāng)中的幾個(gè)方法，也就是上面了不起給大家寫(xiě)的除了自定義線程池的幾個(gè)方法。

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

在源碼中有一個(gè)類，我們明顯的看到了隊(duì)列的身影，那就是 LinkedBlockingQueue。

它實(shí)現(xiàn)了一個(gè)基于鏈接節(jié)點(diǎn)的可選容量的阻塞隊(duì)列。此隊(duì)列按 FIFO（先進(jìn)先出）排序元素。隊(duì)列的頭部是在隊(duì)列中存在時(shí)間最長(zhǎng)的元素，隊(duì)列的尾部是在隊(duì)列中存在時(shí)間最短的元素。新元素總是插入到隊(duì)列的尾部，而檢索操作（如 take 和 poll）總是從隊(duì)列的頭部開(kāi)始。

LinkedBlockingQueue 是一個(gè)線程安全的隊(duì)列，它內(nèi)部使用了鎖和條件變量來(lái)保證多線程環(huán)境下的正確性和一致性。因?yàn)樗亲枞?duì)列，所以它可以用于生產(chǎn)者和消費(fèi)者模型，在生產(chǎn)者線程和消費(fèi)者線程之間傳遞數(shù)據(jù)。

LinkedBlockingQueue 的主要特點(diǎn)就幾個(gè)

• 容量可選
• 阻塞操作
• 非阻塞操作
• 線程安全
• 高效的并發(fā)性能

為什么說(shuō)容量可選呢？因?yàn)槲覀內(nèi)绻麊为?dú)使用這個(gè)LinkedBlockingQueue 那么你可以在創(chuàng)建 LinkedBlockingQueue 時(shí)指定一個(gè)容量，這將限制隊(duì)列中可以存儲(chǔ)的元素?cái)?shù)量。如果未指定容量，則隊(duì)列的容量將是 Integer.MAX_VALUE。當(dāng)隊(duì)列滿時(shí)，任何嘗試插入元素的線程都將被阻塞，直到隊(duì)列中有空間可用。

而阻塞操作則是他提供了阻塞的 put 和 take 方法。put 方法用于添加元素到隊(duì)列中，如果隊(duì)列已滿，則調(diào)用線程將被阻塞直到隊(duì)列有空閑空間。take 方法用于從隊(duì)列中移除并返回頭部元素，如果隊(duì)列為空，則調(diào)用線程將被阻塞直到隊(duì)列中有元素可用。

public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset local var
        // holding count negative to indicate failure unless set.
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        ......
        

public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();
        try {
            while (count.get() == 0) {
                notEmpty.await();
            }
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
.....

我們看一個(gè)使用LinkedBlockingQueue的示例：

import java.util.concurrent.BlockingQueue;  
import java.util.concurrent.LinkedBlockingQueue;  
  
public class ProducerConsumerExample {  
    public static void main(String[] args) throws InterruptedException {  
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);  
  
        Thread producer = new Thread(() -> {  
            try {  
                for (int i = 0; i < 10; i++) {  
                    System.out.println("Produced: " + i);  
                    queue.put(i);  
                    Thread.sleep(200); // 模擬生產(chǎn)耗時(shí)  
                }  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        });  
  
        Thread consumer = new Thread(() -> {  
            try {  
                while (true) {  
                    Integer item = queue.take();  
                    System.out.println("Consumed: " + item);  
                    Thread.sleep(500); // 模擬消費(fèi)耗時(shí)  
                }  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        });  
  
        producer.start();  
        consumer.start();  
  
        producer.join();  
        // 注意：這里的 consumer 線程是一個(gè)無(wú)限循環(huán)，所以它不會(huì)自然結(jié)束。  
        // 在實(shí)際應(yīng)用中，你需要有一個(gè)明確的停止條件來(lái)結(jié)束消費(fèi)者線程。  
    }  
}

說(shuō)到這里感覺(jué)說(shuō)多了，我們回歸正題，如果我們使用標(biāo)準(zhǔn)的 newCachedThreadPool 方法，如果線程數(shù)設(shè)置和任務(wù)數(shù)不能夠配合起來(lái)，就比如說(shuō)設(shè)置的線程數(shù)是一定的，這個(gè)時(shí)候，任務(wù)數(shù)量越多，就會(huì)慢慢的進(jìn)入到隊(duì)列LinkedBlockingQueue中，隊(duì)列的話，任務(wù)越多，占用的內(nèi)存越多，最終就非常容易耗盡內(nèi)存，導(dǎo)致OOM。

所以我們不推薦直接使用 Executors 來(lái)創(chuàng)建線程池，但是我們更推薦使用 ThreadpoolExecutor創(chuàng)建線程池。原因就是如下的幾點(diǎn)：

1.資源控制：ThreadPoolExecutor 允許你明確控制并發(fā)線程的最大數(shù)量，防止因?yàn)閯?chuàng)建過(guò)多的線程而耗盡系統(tǒng)資源。通過(guò)合理地設(shè)置線程池的大小，可以平衡資源利用率和系統(tǒng)性能。

2.線程復(fù)用：線程池中的線程可以被多個(gè)任務(wù)復(fù)用，這減少了在創(chuàng)建和銷毀線程上花費(fèi)的時(shí)間以及開(kāi)銷，提高了系統(tǒng)的響應(yīng)速度。

3.任務(wù)隊(duì)列：ThreadPoolExecutor 內(nèi)部維護(hù)了一個(gè)任務(wù)隊(duì)列，當(dāng)線程池中的線程都在工作時(shí)，新提交的任務(wù)會(huì)被放在隊(duì)列中等待執(zhí)行。這提供了一種緩沖機(jī)制，可以平滑處理突發(fā)的高并發(fā)任務(wù)。

4.靈活性：ThreadPoolExecutor 提供了多種配置選項(xiàng)，如核心線程數(shù)、最大線程數(shù)、線程存活時(shí)間、任務(wù)隊(duì)列類型等，這些選項(xiàng)可以根據(jù)具體的應(yīng)用場(chǎng)景進(jìn)行調(diào)整，以達(dá)到最佳的性能和資源利用率。

5.異常處理：當(dāng)線程池中的線程因?yàn)槲床东@的異常而終止時(shí)，ThreadPoolExecutor 會(huì)創(chuàng)建一個(gè)新的線程來(lái)替代它，從而保持線程池的穩(wěn)定性。此外，你也可以通過(guò)提供自定義的 ThreadFactory 來(lái)控制線程的創(chuàng)建過(guò)程，例如設(shè)置線程的名稱、優(yōu)先級(jí)、守護(hù)狀態(tài)等。

6.可擴(kuò)展性：ThreadPoolExecutor 的設(shè)計(jì)是基于策略的，它使用了多個(gè)接口和抽象類來(lái)定義線程池的行為，這使得它很容易通過(guò)擴(kuò)展或替換某些組件來(lái)適應(yīng)不同的需求。

7.與Java并發(fā)庫(kù)集成：ThreadPoolExecutor 是 Java 并發(fā)庫(kù) java.util.concurrent 的一部分，這個(gè)庫(kù)提供了豐富的并發(fā)工具和類，如鎖、信號(hào)量、倒計(jì)時(shí)器、阻塞隊(duì)列等，這些都可以與 ThreadPoolExecutor 無(wú)縫集成，簡(jiǎn)化多線程編程的復(fù)雜性。

8.性能監(jiān)控和調(diào)優(yōu)：ThreadPoolExecutor 提供了一些有用的方法，如 getTaskCount()、getCompletedTaskCount()、getPoolSize() 等，這些方法可以幫助你監(jiān)控線程池的運(yùn)行狀態(tài)，從而進(jìn)行性能調(diào)優(yōu)。

所以你了解了么？