說一下線程池的核心參數，線程池的執行原理

作者：springboot葵花寶典 2023-11-29 16:38:12

今天一起來說一下線程池的核心參數,線程池的執行原理，大家都知道嗎？

1.線程池的核心參數

線程池七大核心參數如下所示:

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

corePoolSize: 核心線程數目
maximumPoolSize: 最大線程數目 = (核心線程+救急線程的最大數目)
keepAliveTime: 生存時間 - 救急線程的生存時間，生存時間內沒有新任務，此線程資源會釋放
unit: 時間單位 , 救急線程的生存時間單位，如秒、毫秒等
workQueue: 當沒有空閑核心線程時，新來任務會加入到此隊列排隊，隊列滿會創建救急線程執行任務
**threadFactory: 線程工廠 , 可以定制線程對象的創建，例如設置線程名字、是否是守護線程等
handler 拒絕策略 - 當所有線程都在繁忙，workQueue 也放滿時，會觸發拒絕策略

思考:線程池的執行原理知道嘛?

2. 線程池的執行原理

1: 任務在提交的時候，首先判斷核心線程數是否已滿，如果沒有滿則直接添加到工作線程執行

2: 如果核心線程數滿了，則判斷阻塞隊列是否已滿，如果沒有滿，當前任務存入阻塞隊列

3：如果阻塞隊列也滿了，則判斷線程數是否小于最大線程數，如果滿足條件，則使用臨時線程執行任務如果核心或臨時線程執行完成任務后會檢查阻塞隊列中是否有需要執行的線程，如果有，則使用非核心線程執行任務

4:如果所有線程都在忙著（核心線程+臨時線程），則走拒絕策略

思考:拒絕策略有哪些?

1.AbortPolicy：直接拋出異常，默認策略

2.CallerRunsPolicy：用調用者所在的線程來執行任務

3.DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，并執行當前任務

4.DiscardPolicy：直接丟棄任務

案例:

public class TestThreadPoolExecutor {

    static class MyTask implements Runnable {
        private final String name;
        private final long duration;

        public MyTask(String name) {
            this(name, 0);
        }

        public MyTask(String name, long duration) {
            this.name = name;
            this.duration = duration;
        }

        @Override
        public void run() {
            try {
                LoggerUtils.get("myThread").debug("running..." + this);
                Thread.sleep(duration);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "MyTask(" + name + ")";
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicInteger c = new AtomicInteger(1);
        ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(2);
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.MILLISECONDS,
                queue,
                r -> new Thread(r, "myThread" + c.getAndIncrement()),
                new ThreadPoolExecutor.AbortPolicy());
        showState(queue, threadPool);
        threadPool.submit(new MyTask("1", 3600000));
        showState(queue, threadPool);
        threadPool.submit(new MyTask("2", 3600000));
        showState(queue, threadPool);
        threadPool.submit(new MyTask("3"));
        showState(queue, threadPool);
        threadPool.submit(new MyTask("4"));
        showState(queue, threadPool);
        threadPool.submit(new MyTask("5",3600000));
        showState(queue, threadPool);
        threadPool.submit(new MyTask("6"));
        showState(queue, threadPool);
    }

    private static void showState(ArrayBlockingQueue<Runnable> queue, ThreadPoolExecutor threadPool) {
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        List<Object> tasks = new ArrayList<>();
        for (Runnable runnable : queue) {
            try {
                Field callable = FutureTask.class.getDeclaredField("callable");
                callable.setAccessible(true);
                Object adapter = callable.get(runnable);
                Class<?> clazz = Class.forName("java.util.concurrent.Executors$RunnableAdapter");
                Field task = clazz.getDeclaredField("task");
                task.setAccessible(true);
                Object o = task.get(adapter);
                tasks.add(o);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        LoggerUtils.main.debug("pool size: {}, queue: {}", threadPool.getPoolSize(), tasks);
    }

}

思考:線程池中有哪些常見的阻塞隊列？

3. 常見阻塞隊列

workQueue: 當沒有空閑核心線程時，新來任務會加入到此隊列排隊，隊列滿會創建救急線程執行任務。

比較常見的有4個，用的最多是ArrayBlockingQueue和LinkedBlockingQueue。

1.ArrayBlockingQueue：基于數組結構的有界阻塞隊列
2.LinkedBlockingQueue：基于鏈表結構的有界阻塞隊列
3.DelayedWorkQueue ：是一個優先級隊列，它可以保證每次出隊的任務都是當前隊列中執行時間最靠前的
4.SynchronousQueue：不存儲元素的阻塞隊列，每個插入操作都必須等待一個移出操作

3.1. ArrayBlockingQueue的LinkedBlockingQueue區別

inkedBlockingQueue**	ArrayBlockingQueue
默認無界，支持有界	強制有界
底層是鏈表	底層是數組
是懶惰的，創建節點的時候添加數據	提前初始化 Node 數組
入隊會生成新 Node	Node需要是提前創建好的
兩把鎖（頭尾）	一把鎖

左邊是LinkedBlockingQueue加鎖的方式，右邊是ArrayBlockingQueue加鎖的方式

LinkedBlockingQueue：讀和寫各有一把鎖，性能相對較好
ArrayBlockingQueue：只有一把鎖，讀和寫公用，性能相對于LinkedBlockingQueue差一些

4. 線程池的種類有哪些

在java.util.concurrent.Executors類中提供了大量創建連接池的靜態方法，常見就有四種

1.創建使用固定線程數的線程池

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

核心線程數與最大線程數一樣，沒有救急線程
阻塞隊列是LinkedBlockingQueue，最大容量為Integer.MAX_VALUE
適用場景：適用于任務量已知，相對耗時的任務
案例

/**
 * @author springboot葵花寶典
 * @description: TODO
 */
public class FixedThreadPoolTest {

    static class FixedThreadDemo implements Runnable{
        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            for (int i = 0; i < 2; i++) {
                System.out.println(name + ":" + i);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //創建一個固定大小的線程池，核心線程數和最大線程數都是3
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executorService.submit(new FixedThreadDemo());
            Thread.sleep(10);
        }

        executorService.shutdown();
    }

}

2.單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO)執行

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

核心線程數和最大線程數都是1
阻塞隊列是LinkedBlockingQueue，最大容量為Integer.MAX_VALUE
適用場景：適用于按照順序執行的任務
案例

/**
 * @author springboot葵花寶典
 * @description: TODO
 */
public class NewSingleThreadTest {
    static int count = 0;

    static class Demo implements Runnable {
        @Override
        public void run() {
            count++;
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //單個線程池，核心線程數和最大線程數都是1
        ExecutorService exec = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            exec.execute(new Demo());
            Thread.sleep(5);
        }
        exec.shutdown();
    }
}

可緩存線程池

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

核心線程數為0
最大線程數是Integer.MAX_VALUE
阻塞隊列為SynchronousQueue:不存儲元素的阻塞隊列，每個插入操作都必須等待一個移出操作
適用場景：適合任務數比較密集，但每個任務執行時間較短的情況
案例：

/**
 * @author springboot葵花寶典
 * @description: TODO
 */
public class CachedThreadPoolTest {
    static class Demo implements Runnable {
        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            try {
                //修改睡眠時間，模擬線程執行需要花費的時間
                Thread.sleep(100);

                System.out.println(name + "執行完了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //創建一個緩存的線程，沒有核心線程數，最大線程數為Integer.MAX_VALUE
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            exec.execute(new Demo());
            Thread.sleep(1);
        }
        exec.shutdown();
    }
}

4.提供了“延遲”和“周期執行”功能的ThreadPoolExecutor

public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler{
 super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory, handler);                     
}

適用場景：有定時和延遲執行的任務
案例

/**
 * @author springboot葵花寶典
 * @description: TODO
 */
public class ScheduledThreadPoolTest {
    static class Task implements Runnable {
        @Override
        public void run() {
            try {
                String name = Thread.currentThread().getName();

                System.out.println(name + ", 開始：" + new Date());
                Thread.sleep(1000);
                System.out.println(name + ", 結束：" + new Date());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //按照周期執行的線程池，核心線程數為2，最大線程數為Integer.MAX_VALUE
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
        System.out.println("程序開始：" + new Date());

        /**
         * schedule 提交任務到線程池中
         * 第一個參數：提交的任務
         * 第二個參數：任務執行的延遲時間
         * 第三個參數：時間單位
         */
        scheduledThreadPool.schedule(new Task(), 0, TimeUnit.SECONDS);
        scheduledThreadPool.schedule(new Task(), 1, TimeUnit.SECONDS);
        scheduledThreadPool.schedule(new Task(), 5, TimeUnit.SECONDS);

        Thread.sleep(5000);

        // 關閉線程池
        scheduledThreadPool.shutdown();

    }
}

5. 線程池面試題

面試官：線程池的核心參數有哪些？

候選人：

在線程池中一共有7個核心參數：

corePoolSize 核心線程數目 - 池中會保留的最多線程數
maximumPoolSize 最大線程數目 - 核心線程+救急線程的最大數目
keepAliveTime 生存時間 - 救急線程的生存時間，生存時間內沒有新任務，此線程資源會釋放
unit 時間單位 - 救急線程的生存時間單位，如秒、毫秒等
workQueue - 當沒有空閑核心線程時，新來任務會加入到此隊列排隊，隊列滿會創建救急線程執行任務
threadFactory 線程工廠 - 可以定制線程對象的創建，例如設置線程名字、是否是守護線程等
handler 拒絕策略 - 當所有線程都在繁忙，workQueue 也放滿時，會觸發拒絕策略

在拒絕策略中又有4中拒絕策略

第一種是AbortPolicy,之際拋異常
第二種是CallerRunsPolicy由調用者執行任務
第三是DiscardOldestPolicy丟棄當前的任務
第四是DiscardPolicy丟棄最早排隊任務。默認是直接拋異常。

面試官：線程池的執行原理知道嗎？

候選人：

首先判斷線程池里的核心線程是否都在執行任務，如果不是則創建一個新的工作線程來執行任務。如果核心線程都在執行任務，則線程池判斷工作隊列是否已滿，如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列里。如果工作隊列滿了，則判斷線程池里的線程是否都處于工作狀態，如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給拒絕策略來處理這個任務。

面試官：線程池的種類有哪些？

候選人：

在jdk中默認提供了4中方式創建線程池

第一個是：newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
第二個是：newFixedThreadPool 創建一個定長線程池，可控制線程最大并發數，超出的線程會在隊列中等待。
第三個是：newScheduledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
第四個是：newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

責任編輯：華軒來源： springboot葵花寶典

線程池阻塞隊列開發