我記得之前在面試的時候，面試官問我單執行緒池有什么意義？我跟面試官說：雖然是單執行緒池，但提供了作業佇列，生命周期管理，作業執行緒維護等功能，

雖然有點籠統，但是誰又能說我說的有錯呢，單執行緒，無論是在面試得程序中還是日常開發，都算是一個很重要的知識點，今天沒什么事情，我就結合原始碼+手寫得案例，帶大家看一下執行緒吃的7種創建方式

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

文章首發公眾號：Java架構師聯盟，每日更新技術好文

1.FixedThreadPool

創建一個固定大小的執行緒池，可控制并發的執行緒數，超出的執行緒會在佇列中等待，

原始碼

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

使用示例如下：

package com.test.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 19:23
 * @description：測驗FixedThreadPool
 */
public class testThread1 {
    public static void fixedThreadPool() {
        // 創建 2 個資料級的執行緒池
        ExecutorService threadPool = Executors.newFixedThreadPool(2);

        // 創建任務
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("任務被執行,執行緒:" + Thread.currentThread().getName());
            }
        };

        // 執行緒池執行任務(一次添加 4 個任務)
        // 執行任務的方法有兩種:submit 和 execute
        threadPool.submit(runnable);  // 執行方式 1:submit
        threadPool.execute(runnable); // 執行方式 2:execute
        threadPool.execute(runnable);
        threadPool.execute(runnable);


    }

    public static void main(String[] args) {
            fixedThreadPool();
    }
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

后來我將測驗數量提交到100，而執行緒池中處理執行緒得數量增加到4

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

執行結果

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

最開始，提交4個執行緒執行，之后的執行緒會在佇列中排序等待被執行

如果覺得以上方法比較繁瑣，還可以用更簡單的使用方法，如下代碼所示：

package com.test.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 19:27
 * @description：FixedThreadPool進階寫法
 */
public class testThreadG {
    public static void fixedThreadPool() {
        // 創建執行緒池
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
       /*
       * 執行任務
       * 為了個之前得進行統一，所以這里通過for回圈，同樣是提交4個執行*/
        for(int i=1;i<=4;i++) {
            threadPool.execute(() -> {
                System.out.println("任務被執行,執行緒:" + Thread.currentThread().getName());
            });
        }
    }

    public static void main(String[] args) {
        fixedThreadPool();
    }
}

2.CachedThreadPool

創建一個可快取的執行緒池，若執行緒數超過處理所需，快取一段時間后會回收，若執行緒數不夠，則新建執行緒，

原始碼

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

引數詳解：

corePoolSize = 0，

maximumPoolSize設定為Integer.MAX_VALUE，代表沒有核心執行緒，非核心執行緒是無界的；keepAliveTime = 60L，空閑執行緒等待新任務的最長時間是60s；

用了阻塞佇列SynchronousQueue,是一個不存盤元素的阻塞佇列

使用示例如下：

package com.test.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 19:38
 * @description：測驗CachedThreadPool
 */
public class testThread2 {
    public static void cachedThreadPool() {
        // 創建執行緒池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        // 執行任務
        for (int i = 0; i < 10; i++) {
            threadPool.execute(() -> {
                System.out.println("任務被執行,執行緒:" + Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
            });
        }
    }

    public static void main(String[] args) {
        cachedThreadPool();
    }
}
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

從上述結果可以看出，執行緒池創建了 10 個執行緒來執行相應的任務，

而如果我將sleep注釋之后，再來看執行結果

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

我想這個結果一目了然吧，大家如果可以的話，可以把這個執行資料提升一下，然后再查看一下結果應該會更明顯

3.SingleThreadExecutor

創建單個執行緒數的執行緒池，它可以保證先進先出的執行順序，為了能讓大家看的更清楚，所以每個執行緒在執行得時候我都添加了他的時間

使用示例如下：

package com.test.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 20:17
 * @description：測驗singleThreadExecutor
 */
public class testThread4 {

    public static void singleThreadExecutor() {
        // 創建執行緒池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 執行任務
        for (int i = 0; i < 10; i++) {
            final int index = i;

            threadPool.execute(() -> {
                new Thread();
                System.out.println(Thread.currentThread().getName()+"開始時間[" + new java.util.Date().getTime());
                System.out.println(index + ":任務被執行");

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName()+"結束時間[" + new java.util.Date().getTime());
            });
        }
    }

    public static void main(String[] args) {
       singleThreadExecutor();

    }
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

4.ScheduledThreadPool

創建一個可以執行延遲任務的執行緒池，

原始碼

這個執行緒得原始碼有一點特殊，由兩部分組成，第一部分

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

這里創建了ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor繼承自ThreadPoolExecutor，主要用于給定延時之后的運行任務或定期處理任務

第二部分

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

使用示例如下：

package com.test.thread;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 20:43
 * @description：測驗ScheduledThreadPool
 */
public class testThread3 {
    public static void scheduledThreadPool() {
        // 創建執行緒池
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
        // 添加定時執行任務(1s 后執行)
        for(int i=0;i<4;i++){
            final int index=i;

        System.out.println(index+"添加任務,時間:" + new Date()+Thread.currentThread().getName());
        threadPool.schedule(() -> {
            System.out.println(index+"任務被執行,時間:" + new Date()+Thread.currentThread().getName());
           /* try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
            }*/
        }, 1, TimeUnit.SECONDS);
    }
    }
    public static void main(String[] args) {
        scheduledThreadPool();
    }
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

5.SingleThreadScheduledExecutor

創建一個單執行緒的可以執行延遲任務的執行緒池，

使用示例如下：

package com.test.thread;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 20:54
 * @description：測驗SingleThreadScheduledExecutor
 */
public class testThread5 {
    public static void SingleThreadScheduledExecutor() {
        // 創建執行緒池
        ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
        // 添加定時執行任務(2s 后執行)
        for (int i=0;i<4;i++) {

    final  int index=i;
            System.out.println(index+"添加任務,時間:" + new Date());
            threadPool.schedule(() -> {
                System.out.println(index+"任務被執行,時間:" + new Date());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
            }, 2, TimeUnit.SECONDS);
        }
    }

    public static void main(String[] args) {
        SingleThreadScheduledExecutor();
    }
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

從上述結果可以看出，任務在 2 秒之后被執行了，符合我們的預期，

6.newWorkStealingPool

創建一個搶占式執行的執行緒池（任務執行順序不確定）

注意：

此方法只有在 JDK 1.8+ 版本中才能使用，

使用示例如下：

public static void workStealingPool() {
    // 創建執行緒池
    ExecutorService threadPool = Executors.newWorkStealingPool();
    // 執行任務
    for (int i = 0; i < 10; i++) {
        final int index = i;
        threadPool.execute(() -> {
            System.out.println(index + " 被執行,執行緒名:" + Thread.currentThread().getName());
        });
    }
    // 確保任務執行完成
    while (!threadPool.isTerminated()) {
    }
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

7.ThreadPoolExecutor

最原始的創建執行緒池的方式，它包含了 7 個引數可供設定，

使用示例如下：

package com.test.thread;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author ：biws
 * @date ：Created in 2020/12/17 21:07
 * @description：測驗ThreadPoolExecutor
 */
public class testThread7 {
    public static void myThreadPoolExecutor() {
        // 創建執行緒池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5,
                10,
                100,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
        // 執行任務
        for (int i = 0; i < 10; i++) {
            final int index = i;
            threadPool.execute(() -> {
                System.out.println(index + " 被執行,執行緒名:" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    public static void main(String[] args) {
        myThreadPoolExecutor();
    }
}

執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

ThreadPoolExecutor 引數介紹

就像我前面説的，ThreadPoolExecutor 是可以設定一些引數的，在我的代碼中，我只設定了這幾個引數

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

在原始碼中是這樣撰寫的

    public ThreadPoolExecutor(
      												int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

7 個引數代表的含義如下：

corePoolSize

核心執行緒數，執行緒池中始終存活的執行緒數，

maximumPoolSize

最大執行緒數，執行緒池中允許的最大執行緒數，當執行緒池的任務佇列滿了之后可以創建的最大執行緒數，

keepAliveTime \ unit:

最大執行緒數可以存活的時間，當執行緒中沒有任務執行時，最大執行緒就會銷毀一部分，最終保持核心執行緒數量的執行緒，

單位是和引數 3 存活時間配合使用的，合在一起用于設定執行緒的存活時間

threadFactory

執行緒工廠，主要用來創建執行緒，默認為正常優先級、非守護執行緒，

workQueue

一個阻塞佇列，用來存盤執行緒池等待執行的任務，均為執行緒安全，它包含以下 7 種型別：

ArrayBlockingQueue：一個由陣列結構組成的有界阻塞佇列，

LinkedBlockingQueue：一個由鏈表結構組成的有界阻塞佇列，

SynchronousQueue：一個不存盤元素的阻塞佇列，即直接提交給執行緒不保持它們，

PriorityBlockingQueue：一個支持優先級排序的無界阻塞佇列，

DelayQueue：一個使用優先級佇列實作的無界阻塞佇列，只有在延遲期滿時才能從中提取元素，

LinkedTransferQueue：一個由鏈表結構組成的無界阻塞佇列，與SynchronousQueue類似，還含有非阻塞方法，

LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞佇列，

較常用的是 LinkedBlockingQueue 和 Synchronous，執行緒池的排隊策略與 BlockingQueue 有關，

handler

拒絕策略，拒絕處理任務時的策略，系統提供了 4 種可選：

默認策略為 AbortPolicy，

代碼演示

，，，，，
        // 創建執行緒,執行緒的任務佇列的長度為 1
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                new ThreadPoolExecutor.DiscardPolicy());
，，，，

//在Java種共有4種拒絕策略
/*
AbortPolicy：拒絕并拋出例外，

CallerRunsPolicy：使用當前呼叫的執行緒來執行此任務，

DiscardOldestPolicy：拋棄佇列頭部（最舊）的一個任務，并執行當前任務，

DiscardPolicy：忽略并拋棄當前任務，
*/

演示結果

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

我們創建了一個核心執行緒數和最大執行緒數都為 1 的執行緒池，并且給執行緒池的任務佇列設定為 1，這樣當我們有 2 個以上的任務時就會觸發拒絕策略，

自定義拒絕策略

除了 Java 自身提供的 4 種拒絕策略之外，我們也可以自定義拒絕策略，示例代碼如下：

，，，

        // 創建執行緒,執行緒的任務佇列的長度為 1
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        // 執行自定義拒絕策略的相關操作
                        System.out.println("我是自定義拒絕策略~");
                    }
                });

，，，

程式的執行結果如下：

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

執行緒池的執行流程

提交一個任務到執行緒池中，執行緒池的處理流程如下：

1、判斷執行緒池里的核心執行緒是否都在執行任務，如果不是（核心執行緒空閑或者還有核心執行緒沒有被創建）則創建一個新的作業執行緒來執行任務，如果核心執行緒都在執行任務，則進入下個流程，

2、執行緒池判斷作業佇列是否已滿，如果作業佇列沒有滿，則將新提交的任務存盤在這個作業佇列里，如果作業佇列滿了，則進入下個流程，

3、判斷執行緒池里的執行緒是否都處于作業狀態，如果沒有，則創建一個新的作業執行緒來執行任務，如果已經滿了，則交給飽和策略來處理這個任務，

90分鐘10個手寫案例，從原始碼底層給你講解7種執行緒池創建方式

總結

今天，我花費90分鐘得時間，一點點得手敲案例，將7個執行緒池的創建方式進行講解，但是在日常得生活中，我應用最多的就是hreadPoolExecutor，因為他的引數以及拒絕策略有時會讓開發程序更加可控一些，并且支持自定義，這就很6

希望本文的內容能幫助到你，原創不易，覺得不錯就點個贊再走吧！

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

標籤：Java

上一篇：只會用wait和notify？30分鐘案例告訴你有更好得選擇

下一篇：RocketMQ 的幾個簡單問題與答案