Java併發編程：線程池 ThreadPoolExector 學習篇

常見大廠面試題型：

線程池使用過嗎？談談對 ThreadPoolExector 的理解？
爲什使用線程池，線程池的優勢？
創建線程的幾種方式？
線程池如何使用？
線程池的幾個重要參數介紹？
說說線程池的底層工作原理？
線程池的拒絕策略你談談？
你在工作中單一的、固定數的和可變的三種創建線程池的方法，你用哪個多？
你在工作中是如何使用線程池的，是否自定義過線程池使用？
合理配置線程池你是如果考慮的？

帶着問題學習，我相信能理解的更深刻，掌握的更多。

一、線程池使用過嗎？談談對 ThreadPoolExector 的理解？

根據自己學習情況回答。

二、爲什使用線程池，線程池的優勢？

線程池用於多線程處理中，它可以根據系統的情況，可以有效控制線程執行的數量，優化運行效果。線程池做的工作主要是：控制運行的線程的數量，處理過程中將多餘的任務放入阻塞隊列，然後創建線程啓動這些任務，如果線程數量超過了最大數量，那麼超出數量的線程排隊等候，等其它線程執行完畢，再從隊列中取出任務來執行。

主要特點爲：

線程複用
控制最大併發數量
管理線程

主要優點：

降低資源消耗，通過重複利用已創建的線程來降低線程創建和銷燬造成的消耗。
提高相應速度，當任務到達時，任務可以不需要的等到線程創建就能立即執行。
提高線程的可管理性，線程是稀缺資源，如果無限制的創建，不僅僅會消耗系統資源，還會降低體統的穩定性，使用線程可以進行統一分配，調優和監控。

三、創建線程的幾種方式

繼承 Thread
實現 Runnable 接口
實現 Callable

舉例：Thread 、Runnable就不舉例了，下面是通過Callable接口實現：

public class CallableDemo {

public static void main(String[] args) throws ExecutionException, InterruptedException {

    // 在 FutureTask 中傳入 Callable 的實現類
    FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            return 12;   
        }
    });

    // 把 futureTask 放入線程中
    new Thread(futureTask).start();

    // 獲取結果
    Integer res = futureTask.get();
    System.out.println(res);

    }

}

四、線程池如何使用？

1、架構說明：

2、編碼實現：

常用3種：

Executors.newSingleThreadExecutor()：只有一個線程的線程池，因此所有提交的任務是順序執行，適用於一個一個任務執行的場景

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

Executors.newCachedThreadPool()：線程池裏有很多線程需要同時執行，老的可用線程將被新的任務觸發重新執行，如果線程超過60秒內沒執行，那麼將被終止並從池中刪除，適用執行很多短期異步的小程序或者負載較輕的服務

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

Executors.newFixedThreadPool()：擁有固定線程數的線程池，如果沒有任務執行，那麼線程會一直等待，適用執行長期的任務，性能好很多。

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

不常用：

Executors.newScheduledThreadPool()：用來調度即將執行的任務的線程池
Executors.newWorkStealingPool()： newWorkStealingPool適合使用在很耗時的操作，但是newWorkStealingPool不是ThreadPoolExecutor的擴展，它是新的線程池類ForkJoinPool的擴展，但是都是在統一的一個Executors類中實現，由於能夠合理的使用CPU進行對任務操作（並行操作），所以適合使用在很耗時的任務中

可以發現每種方式的底層最終還是通過ThreadPoolExecutor來實現線程池

ThreadPoolExecutor作爲java.util.concurrent包對外提供基礎實現，以內部線程池的形式對外提供管理任務執行，線程調度，線程池管理等等服務。

五、線程池的幾個重要參數介紹？

ThreadPoolExecutor底層源碼，帶有7個參數：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

核心參數：前5個

參數	作用
corePoolSize	核心線程池大小
maximumPoolSize	最大線程池大小
keepAliveTime	線程池中超過 corePoolSize 數目的空閒線程最大存活時間；可以allowCoreThreadTimeOut(true) 使得核心線程有效時間
TimeUnit	keepAliveTime 時間單位
workQueue	阻塞任務隊列
threadFactory	新建線程工廠
RejectedExecutionHandler	拒絕策略。當提交任務數超過 maxmumPoolSize+workQueue 之和時，任務會交給RejectedExecutionHandler 來處理

六、說說線程池的底層工作原理？

重點講解：

其中比較容易讓人誤解的是：參數corePoolSize，maximumPoolSize，workQueue之間關係。

當線程池小於corePoolSize時，新提交任務將創建一個新線程執行任務，即使此時線程池中存在空閒線程。
當線程池達到corePoolSize時，新提交任務將被放入 workQueue 中，等待線程池中任務調度執行。
當workQueue已滿，且 maximumPoolSize 大於 corePoolSize 時，新提交任務會創建新線程執行任務。
當提交任務數超過 maximumPoolSize 時，新提交任務由 RejectedExecutionHandler 處理。
當線程池中超過corePoolSize 線程，空閒時間達到 keepAliveTime 時，關閉空閒線程。
當設置allowCoreThreadTimeOut(true) 時，線程池中 corePoolSize 線程空閒時間達到 keepAliveTime 也將關閉。

推薦看juc底層視頻學習一下：本人學習教程，尚硅谷周陽線程池詳解

七、線程池的拒絕策略你談談？

1、什麼是拒絕策略：

等待隊列已經滿了，再也塞不下新的任務，同時線程池中的線程數達到了最大線程數max，無法繼續爲新任務服務。此時，我們需要拒絕策略機制合理的處理這個問題。也就是七大參數之一：RejectedExecutionHandler

2、拒絕策略有哪些：

AbortPolicy（默認）：處理程序遭到拒絕將拋出運行時 RejectedExecutionException，阻止系統的正常運行。

CallerRunsPolicy：線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度，既不會拋棄任務，也不會拋出異常，而是將某些任務回退到調用者，從而降低任務的流量。

DiscardPolicy：不能執行的任務將被刪除，直接丟棄任務

DiscardOldestPolicy：如果執行程序尚未關閉，則位於工作隊列頭部的任務將被刪除，然後重試執行程序（如果再次失敗，則重複此過程）。拋棄隊列中等待最久的任務

八、你在工作中單一的、固定數的和可變的三種創建線程池的方法，你用哪個多，超級大坑？

聰明的人的回答應該不是這三者中的任何一個，而是自己創建線程池。如果讀者對Java中的阻塞隊列有所瞭解的話，看到這裏或許就能夠明白原因了。

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

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

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

這裏的問題就出在：

不設置的話，將是一個無邊界的阻塞隊列，最大長度爲Integer.MAX_VALUE。也就是說，如果我們不設置LinkedBlockingQueue的容量的話，其默認容量將會是Integer.MAX_VALUE。而newFixedThreadPool中創建LinkedBlockingQueue時，並未指定容量。此時，LinkedBlockingQueue就是一個無邊界隊列，對於一個無邊界隊列來說，是可以不斷的向隊列中加入任務的，這種情況下就有可能因爲任務過多而導致內存溢出問題OOM。

九、你在工作中是如何使用線程池的，是否自定義過線程池使用？

自定義線程池，以及api方式舉例：

package com.juc.threadpool;

import java.util.concurrent.*;

/**
 * @program: acmPractice
 * @description: 線程池應用
 * @author: Mr.Li
 * @create: 2019-10-09 20:33
 **/
public class MyThreadPoolDemo {
    public static void main(String[] args) {
        //一池5個線程處理
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);

        //一池一線程
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();

        //一池n線程
        //ExecutorService threadPool = Executors.newCachedThreadPool();

        //自定義線程池
        ExecutorService threadPool = new ThreadPoolExecutor(2,5,1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());  
               //4種拒絕策略.AbortPolicy,CallerRunsPolicy,DiscardPolicy,DiscardOldestPolicy
               //不同的策略方式，運行結果也將不一致

        //模擬10個用戶來辦理業務，每個用戶就是一個來自外部的請求線程
        for(int i = 1; i <= 10; i++) {
            threadPool.execute(()->{
                System.out.println(Thread.currentThread().getName() + "辦理業務");
            });
        }

    }
}

十、合理配置線程池你是如果考慮的？

1、CPU 密集型

CPU 密集的意思是該任務需要大量的運算，而沒有阻塞，CPU 一直全速運行。
CPU 密集型任務儘可能的少的線程數量，一般爲 CPU 核數 + 1 個線程的線程池。

2、IO 密集型

由於 IO 密集型任務線程並不是一直在執行任務，可以多分配一點線程數，如 CPU * 2
也可以使用公式：CPU 核數 / (1 - 阻塞係數)；其中阻塞係數在 0.8 ～ 0.9 之間。

擴展

十一、死鎖編碼以及定位分析

產生死鎖的原因：

死鎖是指兩個或兩個以上的進程在執行過程中，因爭奪資源而造成的一種相互等待的現象，如果無外力的干涉那它們都將無法推進下去，如果系統的資源充足，進程的資源請求都能夠得到滿足，死鎖出現的可能性就很低，否則就會因爭奪有限的資源而陷入死鎖。

代碼體現：

package com.juc.deadlock;

import java.util.concurrent.TimeUnit;

/**
 * @description: 造成死鎖的原因，如何排除
 * @author: Mr.Li
 * @create: 2019-10-10 15:53
 **/
class HoldLockThread implements Runnable {
    private String lockA;
    private String lockB;

    public HoldLockThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "\t自己持有" + lockA + "嘗試獲得" + lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "\t自己持有" + lockB + "嘗試獲得" + lockA);
            }
        }
    }
}

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new HoldLockThread(lockA,lockB),"AA").start();
        new Thread(new HoldLockThread(lockB,lockA),"BB").start();
    }
}

運行：程序始終未結束，並不知道發生什麼錯誤

如何排查問題及相應解決：首先轉到終端，輸入命令 jsp -l 查出對應程序的進程號爲 4184

然後輸入命令：jstack 4184

可看到結果：發現一處死鎖錯誤

Java stack information for the threads listed above:
===================================================
"BB":
        at com.juc.deadlock.HoldLockThread.run(DeadLockDemo.java:30)
        - waiting to lock <0x00000000d604bf88> (a java.lang.String)
        - locked <0x00000000d604bfc0> (a java.lang.String)
        at java.lang.Thread.run(Thread.java:748)
"AA":
        at com.juc.deadlock.HoldLockThread.run(DeadLockDemo.java:30)
        - waiting to lock <0x00000000d604bfc0> (a java.lang.String)
        - locked <0x00000000d604bf88> (a java.lang.String)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

好了，也到尾聲了，感謝你的觀看，希望你儘快學會掌握喔！

每日一言：

生活就像海洋，只有一直堅強的人才能到達彼岸

不忘初心Eternity

發佈了63 篇原創文章 · 獲贊 9 · 訪問量 7133

私信關注

Java併發編程：線程池 ThreadPoolExector 學習篇

常見大廠面試題型：

一、線程池使用過嗎？談談對 ThreadPoolExector 的理解？

二、爲什使用線程池，線程池的優勢？

三、創建線程的幾種方式

四、線程池如何使用？

五、線程池的幾個重要參數介紹？

六、說說線程池的底層工作原理？

七、線程池的拒絕策略你談談？

八、你在工作中單一的、固定數的和可變的三種創建線程池的方法，你用哪個多，超級大坑？

九、你在工作中是如何使用線程池的，是否自定義過線程池使用？

十、合理配置線程池你是如果考慮的？

擴展

十一、死鎖編碼以及定位分析

Python 潮流週刊#50：我最喜歡的 Python 3.13 新特性！

6月&劍指offer刷題記錄

目前市面應用廣泛的幾款服務器軟件

Mybatis入門，通過代理對象實現CRUD快速理解

基於servlet+jsp 個人博客系統

JUC併發包：CountDownLatch、CyclicBarrier、Semaphore使用

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結