java四種執行緒池的使用

阿新 • • 發佈：2021-07-01

一、四種執行緒池

Java通過Executors提供四種執行緒池，分別為

newSingleThreadExecutor建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。
newFixedThreadPool建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。
newScheduledThreadPool建立一個可定期或者延時執行任務的定長執行緒池，支援定時及週期性任務執行。
newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。

二、核心類

四種執行緒池本質都是建立ThreadPoolExecutor類，ThreadPoolExecutor構造引數如下

int corePoolSize, 核心執行緒大小
int maximumPoolSize,最大執行緒大小
long keepAliveTime, 超過corePoolSize的執行緒多久不活動被銷燬時間
TimeUnit unit,時間單位
BlockingQueue<Runnable>workQueue 任務佇列
ThreadFactory threadFactory 執行緒池工廠
RejectedExecutionHandler handler 拒絕策略

三、阻塞佇列

ArrayBlockingQueue ：一個由陣列結構組成的有界阻塞佇列
LinkedBlockingQueue ：一個由連結串列結構組成的有界阻塞佇列（常用）
PriorityBlockingQueue ：一個支援優先順序排序的無界阻塞佇列
DelayQueue：一個使用優先順序佇列實現的無界阻塞佇列
SynchronousQueue：一個不儲存元素的阻塞佇列（常用）
LinkedTransferQueue：一個由連結串列結構組成的無界阻塞佇列
LinkedBlockingDeque：一個由連結串列結構組成的雙向阻塞佇列

四、四種預設執行緒池原始碼初步分析

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

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

//建立一個定長執行緒池，支援定時及週期性任務執行。延遲執行
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
}

檢視原始碼，四種執行緒池都是建立了ThreadPollExecutor物件，只是傳遞的引數不一樣而已，觀察傳入的workQueue 都是預設，即最大可新增Integer.MAX_VALUE個任務，這也就是阿里巴巴java開發規範禁止直接使用java提供的預設執行緒池的原因了

五、執行緒池任務執行流程

當執行緒池小於corePoolSize時，新提交任務將建立一個新執行緒執行任務，即使此時執行緒池中存在空閒執行緒。
當執行緒池達到corePoolSize時，新提交任務將被放入workQueue中，等待執行緒池中任務排程執行
當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會建立新執行緒執行任務
當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理
當執行緒池中超過corePoolSize執行緒，空閒時間達到keepAliveTime時，釋放空閒執行緒
當設定allowCoreThreadTimeOut(true)時，該引數預設false，執行緒池中corePoolSize執行緒空閒時間達到keepAliveTime也將關閉

六、使用場景詳解

newCachedThreadPool：

底層：返回ThreadPoolExecutor例項，corePoolSize為0；maximumPoolSize為Integer.MAX_VALUE；keepAliveTime為60L；時間單位TimeUnit.SECONDS；workQueue為SynchronousQueue(同步佇列)
通俗：當有新任務到來，則插入到SynchronousQueue中，由於SynchronousQueue是同步佇列，因此會在池中尋找可用執行緒來執行，若有可以執行緒則執行，若沒有可用執行緒則建立一個執行緒來執行該任務；若池中執行緒空閒時間超過指定時間，則該執行緒會被銷燬。
適用：執行很多短期的非同步任務

/**
 * 1.建立一個可快取的執行緒池。如果執行緒池的大小超過了處理任務所需要的執行緒，那麼就會回收部分空閒（60秒不執行任務）的執行緒<br>
 * 2.當任務數增加時，此執行緒池又可以智慧的新增新執行緒來處理任務<br>
 * 3.此執行緒池不會對執行緒池大小做限制，執行緒池大小完全依賴於作業系統（或者說JVM）能夠建立的最大執行緒大小<br>
 */
public static void cacheThreadPool() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 10; i++) {
            final int ii = i;
            try {
                Thread.sleep(ii * 1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(()->out.println("執行緒名稱：" + Thread.currentThread().getName() + "，執行" + ii));
        }
}
-----output------
執行緒名稱：pool-1-thread-1，執行1
執行緒名稱：pool-1-thread-1，執行2
執行緒名稱：pool-1-thread-1，執行3
執行緒名稱：pool-1-thread-1，執行4
執行緒名稱：pool-1-thread-1，執行5
執行緒名稱：pool-1-thread-1，執行6
執行緒名稱：pool-1-thread-1，執行7
執行緒名稱：pool-1-thread-1，執行8
執行緒名稱：pool-1-thread-1，執行9
執行緒名稱：pool-1-thread-1，執行10

newFixedThreadPool：

底層：返回ThreadPoolExecutor例項，接收引數為所設定執行緒數量n，corePoolSize和maximumPoolSize均為n；keepAliveTime為0L；時間單位TimeUnit.MILLISECONDS；WorkQueue為：new LinkedBlockingQueue<Runnable>()無界阻塞佇列
通俗：建立可容納固定數量執行緒的池子，每個執行緒的存活時間是無限的，當池子滿了就不再新增執行緒了；如果池中的所有執行緒均在繁忙狀態，對於新任務會進入阻塞佇列中(無界的阻塞佇列)
適用：執行長期任務

/**
  * 1.建立固定大小的執行緒池。每次提交一個任務就建立一個執行緒，直到執行緒達到執行緒池的最大大小<br>
  * 2.執行緒池的大小一旦達到最大值就會保持不變，如果某個執行緒因為執行異常而結束，那麼執行緒池會補充一個新執行緒<br>
  * 3.因為執行緒池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒列印3個數字，和執行緒名稱<br>
  */
public static void fixTheadPoolTest() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            fixedThreadPool.execute(() -> {
                out.println("執行緒名稱：" + Thread.currentThread().getName() + "，執行" + ii);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
}
------output-------
執行緒名稱：pool-1-thread-3，執行2
執行緒名稱：pool-1-thread-1，執行0
執行緒名稱：pool-1-thread-2，執行3
執行緒名稱：pool-1-thread-3，執行4
執行緒名稱：pool-1-thread-1，執行5
執行緒名稱：pool-1-thread-2，執行6
執行緒名稱：pool-1-thread-3，執行7
執行緒名稱：pool-1-thread-1，執行8
執行緒名稱：pool-1-thread-3，執行9

newSingleThreadExecutor:

底層：FinalizableDelegatedExecutorService包裝的ThreadPoolExecutor例項，corePoolSize為1；maximumPoolSize為1；keepAliveTime為0L；時間單位TimeUnit.MILLISECONDS；workQueue為：new LinkedBlockingQueue<Runnable>()無解阻塞佇列
通俗：建立只有一個執行緒的執行緒池，當該執行緒正繁忙時，對於新任務會進入阻塞佇列中(無界的阻塞佇列)
適用：按順序執行任務的場景

/**  *建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行
 */
public static void singleTheadPoolTest() {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            pool.execute(() -> out.println(Thread.currentThread().getName() + "=>" + ii));
        }
}

-----output-------
執行緒名稱：pool-1-thread-1，執行0
執行緒名稱：pool-1-thread-1，執行1
執行緒名稱：pool-1-thread-1，執行2
執行緒名稱：pool-1-thread-1，執行3
執行緒名稱：pool-1-thread-1，執行4
執行緒名稱：pool-1-thread-1，執行5
執行緒名稱：pool-1-thread-1，執行6
執行緒名稱：pool-1-thread-1，執行7
執行緒名稱：pool-1-thread-1，執行8
執行緒名稱：pool-1-thread-1，執行9

NewScheduledThreadPool:

底層：建立ScheduledThreadPoolExecutor例項，該物件繼承了ThreadPoolExecutor，corePoolSize為傳遞來的引數，maximumPoolSize為Integer.MAX_VALUE；keepAliveTime為0；時間單位TimeUnit.NANOSECONDS；workQueue為：new DelayedWorkQueue()一個按超時時間升序排序的佇列
通俗：建立一個固定大小的執行緒池，執行緒池內執行緒存活時間無限制，執行緒池可以支援定時及週期性任務執行，如果所有執行緒均處於繁忙狀態，對於新任務會進入DelayedWorkQueue佇列中，這是一種按照超時時間排序的佇列結構
適用：執行週期性任務
```
/**
 * 建立一個定長執行緒池，支援定時及週期性任務執行。延遲執行
 */
public static void sceduleThreadPool() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        Runnable r1 = () -> out.println("執行緒名稱：" + Thread.currentThread().getName() + "，執行:3秒後執行");
        scheduledThreadPool.schedule(r1, 3, TimeUnit.SECONDS);
        Runnable r2 = () -> out.println("執行緒名稱：" + Thread.currentThread().getName() + "，執行:延遲2秒後每3秒執行一次");
        scheduledThreadPool.scheduleAtFixedRate(r2, 2, 3, TimeUnit.SECONDS);
        Runnable r3 = () -> out.println("執行緒名稱：" + Thread.currentThread().getName() + "，執行:普通任務");
        for (int i = 0; i < 5; i++) {
            scheduledThreadPool.execute(r3);
        }
}
----output------
執行緒名稱：pool-1-thread-1，執行:普通任務
執行緒名稱：pool-1-thread-5，執行:普通任務
執行緒名稱：pool-1-thread-4，執行:普通任務
執行緒名稱：pool-1-thread-3，執行:普通任務
執行緒名稱：pool-1-thread-2，執行:普通任務
執行緒名稱：pool-1-thread-1，執行:延遲2秒後每3秒執行一次
執行緒名稱：pool-1-thread-5，執行:3秒後執行
執行緒名稱：pool-1-thread-4，執行:延遲2秒後每3秒執行一次
執行緒名稱：pool-1-thread-4，執行:延遲2秒後每3秒執行一次
執行緒名稱：pool-1-thread-4，執行:延遲2秒後每3秒執行一次
執行緒名稱：pool-1-thread-4，執行:延遲2秒後每3秒執行一次
```
七、備註：
- 一般如果執行緒池任務佇列採用LinkedBlockingQueue佇列的話，那麼不會拒絕任何任務（因為其大小為Integer.MAX_VALUE），這種情況下，ThreadPoolExecutor最多僅會按照最小執行緒數corePoolSize來建立執行緒，也就是說執行緒池大小被忽略了。
- 如果執行緒池任務佇列採用ArrayBlockingQueue佇列，初始化設定了最大佇列數。那麼ThreadPoolExecutor的maximumPoolSize才會生效，那麼ThreadPoolExecutor的maximumPoolSize才會生效會採用新的演算法處理任務，
- 例如假定執行緒池的最小執行緒數為4，最大為8，ArrayBlockingQueue最大為10。隨著任務到達並被放到佇列中，執行緒池中最多執行4個執行緒（即核心執行緒數）直到佇列完全填滿，也就是說等待狀態的任務小於等於10，ThreadPoolExecutor也只會利用4個核心執行緒執行緒處理任務。
- 如果佇列已滿，而又有新任務進來，此時才會啟動一個新執行緒，這裡不會因為佇列已滿而拒接該任務，相反會啟動一個新執行緒。新執行緒會執行佇列中的第一個任務，為新來的任務騰出空間。如果執行緒數已經等於最大執行緒數，任務佇列也已經滿了，則執行緒池會拒絕這個任務，預設拒絕策略是丟擲異常。
- 這個演算法背的理念是：該池大部分時間僅使用核心執行緒（4個），即使有適量的任務在佇列中等待執行。這時執行緒池就可以用作節流閥。如果擠壓的請求變得非常多，這時該池就會嘗試執行更多的執行緒來清理；這時第二個節流閥—最大執行緒數就起作用了。

java四種執行緒池的使用【轉載】

參考:https://blog.csdn.net/w05980598/article/details/79425071 參考:https://blog.csdn.net/achuo/article/details/80623893

Java 四種執行緒池的使用

https://juejin.im/post/59df0c1af265da432f301c8d https://www.cnblogs.com/java-cxh/p/13431789.html 1，執行緒池的作用執行緒池作用就是限制系統中執行執行緒的數量。根據系統的環境情況，可以自動或手動設定執

java四種執行緒池的使用

一、四種執行緒池 Java通過Executors提供四種執行緒池，分別為 newSingleThreadExecutor建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

Java 四種執行緒池的用法分析

Java 四種執行緒池的用法分析 1、new Thread的弊端執行一個非同步任務你還只是如下new Thread嗎？

Java程式中常用的四種執行緒池示例

在Java中使用執行緒池，可以用ThreadPoolExecutor的建構函式直接創建出執行緒池例項，如何使用參見之前的文章Java執行緒池構造引數詳解。不過，在Executors類中，為我們提供了常用執行緒池的建立方法。接下來我們就來

Java中常用的四種執行緒池，你瞭解多少？

newFixedThreadPool 首先，看一下這種執行緒池的建立方法： public static ExecutorService newFixedThreadPool(int nThreads) {

java中常見的四種執行緒池

前言：我們之前使用執行緒的時候都是使用new Thread來進行執行緒的建立，但是這樣會有一些問題。如：

java中四種執行緒池及poolSize、corePoolSize、maximumPoolSize

Executors提供四種執行緒池： newCachedThreadPool ：快取執行緒池，如果執行緒池長度超過處理需要，可回收空閒執行緒，若無可回收，則新建執行緒。

四種執行緒池的解析

首先我們先看一下獲取四種執行緒池的程式碼： ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

四種執行緒池拒絕策略

一、前言執行緒池，相信很多人都有用過，沒用過相信的也有學習過。但是，執行緒池的拒絕策略，相信知道的人會少許多。

轉載(一)-java常用的幾種執行緒池比較

轉載-https://www.cnblogs.com/aaron911/p/6213808.html 1.為什麼使用執行緒池諸如 Web 伺服器、資料庫伺服器、檔案伺服器或郵件伺服器之類的許多伺服器應用程式都面向處理來自某些遠端來源的大量短小的任務。請求以

java中常見的6種執行緒池示例詳解

之前我們介紹了執行緒池的四種拒絕策略，瞭解了執行緒池引數的含義，那麼今天我們來聊聊Java 中常見的幾種執行緒池，以及在jdk7 加入的 ForkJoin 新型執行緒池

java執行緒池詳解及五種執行緒池方法詳解

基礎知識 Executors建立執行緒池 Java中建立執行緒池很簡單，只需要呼叫Executors中相應的便捷方法即可，比如Executors.newFixedThreadPool(int nThreads)，但是便捷不僅隱藏了複雜性，也為我們埋下了潛在的隱患（

Java手動配置執行緒池過程詳解

執行緒池中，常見有涉及到的： ExecutorService executorService = Executors.newSingleThreadExecutor();

java 定時器執行緒池（ScheduledThreadPoolExecutor）的實現

前言定時器執行緒池提供了定時執行任務的能力，即可以延遲執行，可以週期性執行。但定時器執行緒池也還是執行緒池，最底層實現還是ThreadPoolExecutor，可以參考我的另外一篇文章多執行緒–精通ThreadPoolExecutor

JAVA 自定義執行緒池的最大執行緒數設定方法

一：CPU密集型：　　定義：CPU密集型也是指計算密集型，大部分時間用來做計算邏輯判斷等CPU動作的程式稱為CPU密集型任務。該型別的任務需要進行大量的計算，主要消耗CPU資源。這種計算密集型任務雖然也可以用多工完

併發程式設計學習筆記（三十四、執行緒池原始碼三，執行緒池狀態）

目錄：位運算複習執行緒池狀態解析位運算複習原碼：一個整數的絕對值轉換成二進位制，若此數為整數最高位為0，為負數最高位為1。

萬字圖文 | 學會Java中的執行緒池，這一篇也許就夠了！

作者：一枝花算不算浪漫來源：https://mp.weixin.qq.com/s/b9zF6jcZQn6wdjzo8C-TmA 執行緒池原理思維導圖.png

Java中的執行緒池

執行緒池 java.util.concurrent.ExecutorService 表述了非同步執行的機制，並且可以讓任務在後臺執行。ExecutorService是一個介面，繼承了Executor介面。Executor介面只包含了一個方法：void execute(Runnable comma

Java 之 JDBC執行緒池（原始碼版）

一、目錄二、程式碼 PoolConstant package cn.kgc.kb08.jdbc.dao3.impl; public interface PoolConstant {

java四種執行緒池的使用

一、四種執行緒池

二、核心類

三、阻塞佇列

四、四種預設執行緒池原始碼初步分析

五、執行緒池任務執行流程

六、使用場景詳解

七、備註：

相關推薦