【Java 多執行緒 2】執行緒池

一、執行緒池的優勢

1. 降低系統資源消耗，通過重用已存在的執行緒，降低執行緒創建和銷毀造成的消耗；
2. 提高系統回應速度，當有任務到達時，通過復用已存在的執行緒，無需等待新執行緒的創建便能立即執行；
3. 方便執行緒并發數的管控，因為執行緒若是無限制的創建，可能會導致記憶體占用過多而產生OOM，并且會造成cpu過度切換（cpu切換執行緒是有時間成本的（需要保持當前執行執行緒的現場，并恢復要執行執行緒的現場）），
4. 提供更強大的功能，延時定時執行緒池，

二、執行緒池主要方法

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

引數詳解

1. corePoolSize（執行緒池基本大小）：當向執行緒池提交一個任務時，若執行緒池已創建的執行緒數小于corePoolSize，即便此時存在空閑執行緒，也會通過創建一個新執行緒來執行該任務，直到已創建的執行緒數大于或等于corePoolSize時，（除了利用提交新任務來創建和啟動執行緒（按需構造），也可以通過 prestartCoreThread() 或 prestartAllCoreThreads() 方法來提前啟動執行緒池中的基本執行緒，）
2. maximumPoolSize（執行緒池最大大小）：執行緒池所允許的最大執行緒個數，當佇列滿了，且已創建的執行緒數小于maximumPoolSize，則執行緒池會創建新的執行緒來執行任務，另外，對于無界佇列，可忽略該引數，
3. keepAliveTime（執行緒存活保持時間）當執行緒池中執行緒數大于核心執行緒數時，執行緒的空閑時間如果超過執行緒存活時間，那么這個執行緒就會被銷毀，直到執行緒池中的執行緒數小于等于核心執行緒數，
4. workQueue（任務佇列）：用于傳輸和保存等待執行任務的阻塞佇列，
5. threadFactory（執行緒工廠）：用于創建新執行緒，threadFactory創建的執行緒也是采用new Thread()方式，threadFactory創建的執行緒名都具有統一的風格：pool-m-thread-n（m為執行緒池的編號，n為執行緒池內的執行緒編號），
6. handler（執行緒飽和策略）：當執行緒池和佇列都滿了，再加入執行緒會執行此策略，

三、執行緒池流程

1、判斷核心執行緒池是否已滿，沒滿則創建一個新的作業執行緒來執行任務，已滿則執行飽和策略，
2、判斷任務佇列是否已滿，沒滿則將新提交的任務添加在作業佇列，已滿則執行飽和策略，
3、判斷整個執行緒池是否已滿，沒滿則創建一個新的作業執行緒來執行任務，已滿則執行飽和策略，

注意：

1. 判斷執行緒池中當前執行緒數是否大于核心執行緒數，如果小于，在創建一個新的執行緒來執行任務，則執行飽和策略，
2. 判斷任務佇列是否已滿，沒滿則將新提交的任務添加在作業佇列，已滿則執行飽和策略，
3. 判斷執行緒池中當前執行緒數是否大于最大執行緒數，如果小于，則創建一個新的執行緒來執行任務，如果大于，則執行飽和策略，

四、執行緒池為什么需要使用（阻塞）佇列？

回到了非執行緒池缺點中的第3點：

1. 因為執行緒若是無限制的創建，可能會導致記憶體占用過多而產生OOM，并且會造成cpu過度切換，
2. 另外回到了非執行緒池缺點中的第1點：
3. 創建執行緒池的消耗較高，
4. 或者下面這個網上并不高明的回答：
5. 執行緒池創建執行緒需要獲取mainlock這個全域鎖，影響并發效率，阻塞佇列可以很好的緩沖，

五、執行緒池為什么要使用阻塞佇列而不使用非阻塞佇列？

阻塞佇列可以保證任務佇列中沒有任務時阻塞獲取任務的執行緒，使得執行緒進入wait狀態，釋放cpu資源，
當佇列中有任務時才喚醒對應執行緒從佇列中取出訊息進行執行，
使得在執行緒不至于一直占用cpu資源，

（執行緒執行完任務后通過回圈再次從任務佇列中取出任務進行執行，代碼片段如下
while (task != null || (task = getTask()) != null) {}），

不用阻塞佇列也是可以的，不過實作起來比較麻煩而已，有好用的為啥不用呢？

六、java中提供的執行緒池

Executors類提供了4種不同的執行緒池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor，

1. newCachedThreadPool：用來創建一個可以無限擴大的執行緒池，適用于負載較輕的場景，執行短期異步任務，（可以使得任務快速得到執行，因為任務時間執行短，可以很快結束，也不會造成cpu過度切換）
2. newFixedThreadPool：創建一個固定大小的執行緒池，因為采用無界的阻塞佇列，所以實際執行緒數量永遠不會變化，適用于負載較重的場景，對當前執行緒數量進行限制，（保證執行緒數可控，不會造成執行緒過多，導致系統負載更為嚴重）
3. newSingleThreadExecutor：創建一個單執行緒的執行緒池，適用于需要保證順序執行各個任務，
4. newScheduledThreadPool：適用于執行延時或者周期性任務，

七、代碼實體

1、四種常見執行緒池

package com.guor.thread;

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

public class Handle implements Runnable {
    private String name;

    public Handle(String name) {
        this.name = "Thread" + name;
    }

    @Override
    public void run() {
        System.out.println(name + "-> start time : " + new Date());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "-> end time : " + new Date());
    }

    public static void main(String[] args) throws InterruptedException {
        scheduledTest();
    }

    //可快取的執行緒池
    private static void cacheTest() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            Handle handle = new Handle(String.valueOf(i));
            newCachedThreadPool.execute(handle);
        }
        newCachedThreadPool.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }

    //固定長度的執行緒池
    private static void fixedTest() {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Handle handle = new Handle(String.valueOf(i));
            newFixedThreadPool.execute(handle);//先執行五個，然后再執行五個
        }
        newFixedThreadPool.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }

    //單執行緒執行緒池
    private static void singleTest() {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            Handle handle = new Handle(String.valueOf(i));
            newSingleThreadExecutor.execute(handle);//單一執行緒分次執行
        }
        newSingleThreadExecutor.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }

    /**
     * 固定長度的執行緒池，而且以延遲或者定時的方式來執行，類似Timer
     *
     * scheduleAtFixedRate 按指定頻率周期執行某個任務
     * scheduleAtFixedRate ，是以上一個任務開始的時間計時，period時間過去后，檢測上一個任務是否執行完畢，
     * 如果上一個任務執行完畢，則當前任務立即執行，如果上一個任務沒有執行完畢，則需要等上一個任務執行完畢后立即執行，
     *
     * scheduleWithFixedDelay 周期定時執行某個任務/按指定頻率間隔執行某個任務(注意)
     * scheduleWithFixedDelay，是以上一個任務結束時開始計時，period時間過去后，立即執行，
     *
     */
    private static void scheduledTest() {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 3; i++) {
            Handle handle = new Handle(String.valueOf(i));
            //執行
            //newScheduledThreadPool.execute(handle);
            //延遲1秒執行
            //newScheduledThreadPool.schedule(handle, 1, TimeUnit.SECONDS);
            //延遲1秒，每隔3秒執行一遍（隔3秒執行，①如果上一次結束，立即執行；②如果上一次未結束，結束立即執行；）
            //newScheduledThreadPool.scheduleAtFixedRate(handle, 1, 3, TimeUnit.SECONDS);
            //延遲1秒，每隔3秒執行一遍(上一個任務結束開始計時)
            newScheduledThreadPool.scheduleWithFixedDelay(handle, 1, 3, TimeUnit.SECONDS);
        }
        //newScheduledThreadPool.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }
}

2、控制臺輸出

3、Callable方式開啟多執行緒

package com.guor.thread;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TaskWithResult implements Callable<String> {
    private int id;

    public TaskWithResult(int id) {
        this.id = id;
    }

    @Override
    public String call() throws Exception {
        System.out.println("call()方法被自動呼叫,干活！！！             " + Thread.currentThread().getName());
        Thread.sleep(2000);
        return "call()方法被自動呼叫，任務的結果是：" + id + "    " + Thread.currentThread().getName();
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        List<Future<String>> list = new ArrayList<Future<String>>();
        // 創建10個任務并執行
        for (int i = 0; i < 10; i++) {
            //使用ExecutorService執行Callable型別的任務，并將結果保存在future變數中
            Future<String> future = newCachedThreadPool.submit(new TaskWithResult(i));
            //將任務執行結果存盤到List中
            list.add(future);
        }

        //啟動一次順序關閉，執行以前提交的任務，但不接受新任務，如果已經關閉，則呼叫沒有其他作用，
        newCachedThreadPool.shutdown();
        for(Future<String> future : list) {
            System.out.println(future.get() + "--date--> " +new Date());
        }
    }
}

4、控制臺輸出

往期精彩內容：

Java知識體系總結（2021版）

超詳細的springBoot學習筆記

Java多執行緒基礎知識總結（絕對經典）

Java面試題總結（附答案）

Vue基礎知識總結（絕對經典）

常見資料結構與演算法整理總結