小伙子，你懂執行緒池的創建嗎？-有解無憂

為什么阿里巴巴要禁用Executors創建執行緒池？看阿里巴巴開發手冊并發編程這塊有一條：執行緒池不允許使用Executors去創建，而是通過ThreadPoolExecutor的方式，通過原始碼分析禁用的原因

一、執行緒池的定義

管理一組作業執行緒，通過執行緒池復用執行緒有以下幾點優點：

減少資源創建 => 減少記憶體開銷，創建執行緒占用記憶體
降低系統開銷 => 創建執行緒需要時間，會延遲處理的請求
提高穩定穩定性 => 避免無限創建執行緒引起的OutOfMemoryError【簡稱OOM】

二、 Executors創建執行緒池的方式

根據回傳的物件型別創建執行緒池可以分為三類：

創建回傳ThreadPoolExecutor物件
創建回傳ScheduleThreadPoolExecutor物件
創建回傳ForkJoinPool物件

三、ThreadPoolExecutor物件

因為這些創建執行緒池的靜態方法都是回傳ThreadPoolExecutor物件，和我們手動創建ThreadPoolExecutor物件的區別就是我們不需要自己傳建構式的引數，ThreadPoolExecutor的建構式共有四個，但最終呼叫的都是同一個：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

建構式引數說明：

corePoolSize => 執行緒池核心執行緒數量
maximumPoolSize => 執行緒池最大數量
keepAliveTime => 空閑執行緒存活時間
unit => 時間單位
workQueue => 執行緒池所使用的緩沖佇列
threadFactory => 執行緒池創建執行緒使用的工廠
handler => 執行緒池對拒絕任務的處理策略

四、執行緒池執行任務邏輯和執行緒池引數的關系

執行邏輯說明：

判斷核心執行緒數是否已滿，核心執行緒數大小和corePoolSize引數有關，未滿則創建執行緒執行任務
若核心執行緒池已滿，判斷佇列是否滿，佇列是否滿和workQueue引數有關，若未滿則加入佇列中
若佇列已滿，判斷執行緒池是否已滿，執行緒池是否已滿和maximumPoolSize引數有關，若未滿創建執行緒執行任務
若執行緒池已滿，則采用拒絕策略處理無法執執行的任務，拒絕策略和handler引數有關

五、Executors創建回傳ThreadPoolExecutor物件

Executors創建回傳ThreadPoolExecutor物件的方法共有三種：

Executors#newCachedThreadPool => 創建可快取的執行緒池
Executors#newSingleThreadExecutor => 創建單執行緒的執行緒池
Executors#newFixedThreadPool => 創建固定長度的執行緒池

5.1Executors#newCachedThreadPool方法

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

CachedThreadPool是一個根據需要創建新執行緒的執行緒池
corePoolSize => 0，核心執行緒池的數量為0
maximumPoolSize => Integer.MAX_VALUE，執行緒池最大數量為Integer.MAX_VALUE，可以認為可以無限創建執行緒
keepAliveTime => 60L
unit => 秒
workQueue => SynchronousQueue

當一個任務提交時，corePoolSize為0不創建核心執行緒，SynchronousQueue是一個不存盤元素的佇列，可以理解為隊里永遠是滿的，因此最侄訓創建非核心執行緒來執行任務，對于非核心執行緒空閑60s時將被回收，**因為Integer.MAX_VALUE非常大，可以認為是可以無限創建執行緒的，在資源有限的情況下容易引起OOM例外

5.2 Executors#newSingleThreadExecutor方法

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

SingleThreadExecutor是單執行緒執行緒池，只有一個核心執行緒

corePoolSize => 1，核心執行緒池的數量為1
maximumPoolSize => 1，執行緒池最大數量為1，即最多只可以創建一個執行緒，唯一的執行緒就是核心執行緒
keepAliveTime => 0L
unit => 毫秒
workQueue => LinkedBlockingQueue

當一個任務提交時，首先會創建一個核心執行緒來執行任務，如果超過核心執行緒的數量，將會放入佇列中，因為LinkedBlockingQueue是長度為Integer.MAX_VALUE的佇列，可以認為是無界佇列，因此往佇列中可以插入無限多的任務，在資源有限的時候容易引起OOM例外，同時因為無界佇列，maximumPoolSize和keepAliveTime引數將無效，壓根就不會創建非核心執行緒

5.3 Executors#newFixedThreadPool方法

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

FixedThreadPool是固定核心執行緒的執行緒池，固定核心執行緒數由用戶傳入

corePoolSize => nThreads，核心執行緒池的數量為1
maximumPoolSize => nThreads，執行緒池最大數量為nThreads，即最多只可以創建nThreads個執行緒
keepAliveTime => 0L
unit => 毫秒
workQueue> LinkedBlockingQueue 它和SingleThreadExecutor類似，唯一的區別就是核心執行緒數不同，并且由于**使用的是LinkedBlockingQueue，在資源有限的時候容易引起OOM例外

六、三種方式總結

FixedThreadPool和SingleThreadExecutor => 允許的請求佇列長度為Integer.MAX_VALUE，可能會堆積大量的請求，從而引起OOM例外
CachedThreadPool => 允許創建的執行緒數為Integer.MAX_VALUE，可能會創建大量的執行緒，從而引起OOM例外

七、OOM例外測驗

public class TaskTest {
    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();
        int i = 0;
        while (true) {
            es.submit(new Task(i++));
        }
    }
}

使用Executors創建的CachedThreadPool，往執行緒池中無限添加執行緒在啟動測驗類之前先將JVM記憶體調整小一點，不然很容易將電腦跑出問題，在idea里：Run -> Edit Configurations

創建到3w多個執行緒的時候開始報OOM錯誤
另外兩個執行緒池就不做測驗了，測驗方法一致，只是創建的執行緒池不一樣

八、如何定義執行緒池引數

CPU密集型 => 執行緒池的大小推薦為CPU數量 + 1，CPU數量可以根據Runtime.availableProcessors方法獲取
IO密集型 => CPU數量 * CPU利用率 * (1 + 執行緒等待時間/執行緒CPU時間)
混合型 => 將任務分為CPU密集型和IO密集型，然后分別使用不同的執行緒池去處理，從而使每個執行緒池可以根據各自的作業負載來調整
阻塞佇列 => 推薦使用有界佇列，有界佇列有助于避免資源耗盡的情況發生
拒絕策略 => 默認采用的是AbortPolicy拒絕策略，直接在程式中拋出 RejectedExecutionException 例外【因為是運行時例外，不強制catch】，這種處理方式不夠優雅，處理拒絕策略有以下幾種比較推薦：
- 在程式中捕獲RejectedExecutionException例外，在捕獲例外中對任務進行處理，針對默認拒絕策略
- 使用CallerRunsPolicy拒絕策略，該策略會將任務交給呼叫execute的執行緒執行【一般為主執行緒】，此時主執行緒將在一段時間內不能提交任何任務，從而使作業執行緒處理正在執行的任務，此時提交的執行緒將被保存在TCP佇列中，TCP佇列滿將會影響客戶端，這是一種平緩的性能降低
- 自定義拒絕策略，只需要實作RejectedExecutionHandler介面即可
- 如果任務不是特別重要，使用DiscardPolicy和DiscardOldestPolicy拒絕策略將任務丟棄也是可以的

如果使用Executors的靜態方法創建ThreadPoolExecutor物件，可以通過使用Semaphore對任務的執行進行限流也可以避免出現OOM例外

九、如何正確的創建執行緒池

9.1 ScheduledExecutorService

ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
	new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build()
);

executorService.execute(() -> System.out.println("run"));

9.2 new ThreadFactoryBuilder()

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

ExecutorService executor = new ThreadPoolExecutor(
		5, 200, 0L, TimeUnit.MILLISECONDS,
		new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy()
);
executor.submit(() -> System.out.println(Thread.currentThread().getName() + "run"));
executor.shutdown();

9.3 ThreadPoolTaskExecutor xml方式

https://juejin.im/post/5dc41c165188257bad4d9e69

https://my.oschina.net/u/4440046/blog/3190998

本文由博客群發一文多發等運營工具平臺 OpenWrite 發布

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/144544.html

標籤：Java

上一篇：Java連載129-廣播資料包、網路編程總結

下一篇：大牛聊Java并發編程原理之執行緒的互斥與協作機制