跟著阿里p7一起學java高併發 - 第18天：玩轉java執行緒池，這一篇就夠了

路人甲Java發表於2019-07-29

java中的執行緒池，這一篇就夠了

java高併發系列第18篇文章。

本文主要內容

什麼是執行緒池
執行緒池實現原理
執行緒池中常見的各種佇列
自定義執行緒建立的工廠
常見的飽和策略
自定義飽和策略
執行緒池中兩種關閉方法有何不同
擴充套件執行緒池
合理地配置執行緒池
執行緒池中執行緒數量的配置

什麼是執行緒池

大家用jdbc操作過資料庫應該知道，運算元據庫需要和資料庫建立連線，拿到連線之後才能運算元據庫，用完之後銷燬。資料庫連線的建立和銷燬其實是比較耗時的，真正和業務相關的操作耗時是比較短的。每個資料庫操作之前都需要建立連線，為了提升系統效能，後來出現了資料庫連線池，系統啟動的時候，先建立很多連線放在池子裡面，使用的時候，直接從連線池中獲取一個，使用完畢之後返回到池子裡面，繼續給其他需要者使用，這其中就省去建立連線的時間，從而提升了系統整體的效能。

執行緒池和資料庫連線池的原理也差不多，建立執行緒去處理業務，可能建立執行緒的時間比處理業務的時間還長一些，如果系統能夠提前為我們建立好執行緒，我們需要的時候直接拿來使用，用完之後不是直接將其關閉，而是將其返回到執行緒中中，給其他需要這使用，這樣直接節省了建立和銷燬的時間，提升了系統的效能。

簡單的說，在使用了執行緒池之後，建立執行緒變成了從執行緒池中獲取一個空閒的執行緒，然後使用，關閉執行緒變成了將執行緒歸還到執行緒池。

執行緒池實現原理

當向執行緒池提交一個任務之後，執行緒池的處理流程如下：

判斷是否達到核心執行緒數，若未達到，則直接建立新的執行緒處理當前傳入的任務，否則進入下個流程
執行緒池中的工作佇列是否已滿，若未滿，則將任務丟入工作佇列中先存著等待處理，否則進入下個流程
是否達到最大執行緒數，若未達到，則建立新的執行緒處理當前傳入的任務，否則交給執行緒池中的飽和策略進行處理。

流程如下圖：

跟著阿里p7一起學java高併發 - 第18天：玩轉java執行緒池，這一篇就夠了

舉個例子，加深理解：

我們們作為開發者，上面都有開發主管，主管下面帶領幾個小弟幹活，CTO給主管授權說，你可以招聘5個小弟幹活，新來任務，如果小弟還不到吳哥，立即去招聘一個來幹這個新來的任務，當5個小弟都招來了，再來任務之後，將任務記錄到一個表格中，表格中最多記錄100個，小弟們會主動去表格中獲取任務執行，如果5個小弟都在幹活，並且表格中也記錄滿了，那你可以將小弟擴充到20個，如果20個小弟都在幹活，並且存放任務的表也滿了，產品經理再來任務後，是直接拒絕，還是讓產品自己幹，這個由你自己決定，小弟們都盡心盡力在幹活，任務都被處理完了，突然公司業績下滑，幾個員工沒事幹，打醬油，為了節約成本，CTO主管把小弟控制到5人，其他15個人直接被幹掉了。所以作為小弟們，別讓自己閒著，多幹活。

原理：先找幾個人幹活，大家都忙於幹活，任務太多可以排期，排期的任務太多了，再招一些人來幹活，最後幹活的和排期都達到上層領導要求的上限了，那需要採取一些其他策略進行處理了。對於長時間不幹活的人，考慮將其開掉，節約資源和成本。

java中的執行緒池

jdk中提供了執行緒池的具體實現，實現類是：java.util.concurrent.ThreadPoolExecutor，主要構造方法：

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

corePoolSize：核心執行緒大小，當提交一個任務到執行緒池時，執行緒池會建立一個執行緒來執行任務，即使有其他空閒執行緒可以處理任務也會創新執行緒，等到工作的執行緒數大於核心執行緒數時就不會在建立了。如果呼叫了執行緒池的prestartAllCoreThreads方法，執行緒池會提前把核心執行緒都創造好，並啟動

maximumPoolSize：執行緒池允許建立的最大執行緒數。如果佇列滿了，並且以建立的執行緒數小於最大執行緒數，則執行緒池會再建立新的執行緒執行任務。如果我們使用了無界佇列，那麼所有的任務會加入佇列，這個引數就沒有什麼效果了

keepAliveTime：執行緒池的工作執行緒空閒後，保持存活的時間。如果沒有任務處理了，有些執行緒會空閒，空閒的時間超過了這個值，會被回收掉。如果任務很多，並且每個任務的執行時間比較短，避免執行緒重複建立和回收，可以調大這個時間，提高執行緒的利用率

unit：keepAliveTIme的時間單位，可以選擇的單位有天、小時、分鐘、毫秒、微妙、千分之一毫秒和納秒。型別是一個列舉java.util.concurrent.TimeUnit，這個列舉也經常使用，有興趣的可以看一下其原始碼

workQueue：工作佇列，用於快取待處理任務的阻塞佇列，常見的有4種，本文後面有介紹

threadFactory：執行緒池中建立執行緒的工廠，可以通過執行緒工廠給每個建立出來的執行緒設定更有意義的名字

handler：飽和策略，當執行緒池無法處理新來的任務了，那麼需要提供一種策略處理提交的新任務，預設有4種策略，文章後面會提到

呼叫執行緒池的execute方法處理任務，執行execute方法的過程：

判斷執行緒池中執行的執行緒數是否小於corepoolsize，是：則建立新的執行緒來處理任務，否：執行下一步
試圖將任務新增到workQueue指定的佇列中，如果無法新增到佇列，進入下一步
判斷執行緒池中執行的執行緒數是否小於maximumPoolSize，是：則新增執行緒處理當前傳入的任務，否：將任務傳遞給handler物件rejectedExecution方法處理

執行緒池的使用步驟：

呼叫構造方法建立執行緒池
呼叫執行緒池的方法處理任務
關閉執行緒池

執行緒池使用的簡單示例

上一個簡單的示例，如下：

package com.itsoku.chat16;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo1 {
    static ThreadPoolExecutor executor = new ThreadPoolExecutor(3,
            5,
            10,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            int j = i;
            String taskName = "任務" + j;
            executor.execute(() -> {
                //模擬任務內部處理耗時
                try {
                    TimeUnit.SECONDS.sleep(j);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + taskName + "處理完畢");
            });
        }
        //關閉執行緒池
        executor.shutdown();
    }
}

輸出：

pool-1-thread-1任務0處理完畢
pool-1-thread-2任務1處理完畢
pool-1-thread-3任務2處理完畢
pool-1-thread-1任務3處理完畢
pool-1-thread-2任務4處理完畢
pool-1-thread-3任務5處理完畢
pool-1-thread-1任務6處理完畢
pool-1-thread-2任務7處理完畢
pool-1-thread-3任務8處理完畢
pool-1-thread-1任務9處理完畢

執行緒池中常見5種工作佇列

任務太多的時候，工作佇列用於暫時快取待處理的任務，jdk中常見的5種阻塞佇列：

ArrayBlockingQueue：是一個基於陣列結構的有界阻塞佇列，此佇列按照先進先出原則對元素進行排序

LinkedBlockingQueue：是一個基於連結串列結構的阻塞佇列，此佇列按照先進先出排序元素，吞吐量通常要高於ArrayBlockingQueue。靜態工廠方法Executors.newFixedThreadPool使用了這個佇列。

SynchronousQueue ：一個不儲存元素的阻塞佇列，每個插入操作必須等到另外一個執行緒呼叫移除操作，否則插入操作一直處理阻塞狀態，吞吐量通常要高於LinkedBlockingQueue，靜態工廠方法Executors.newCachedThreadPool使用這個佇列

PriorityBlockingQueue：優先順序佇列，進入佇列的元素按照優先順序會進行排序

前2種佇列相關示例就不說了，主要說一下後面2種佇列的使用示例。

SynchronousQueue佇列的執行緒池

package com.itsoku.chat16;

import java.util.concurrent.*;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo2 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 50; i++) {
            int j = i;
            String taskName = "任務" + j;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "處理" + taskName);
                //模擬任務內部處理耗時
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executor.shutdown();
    }
}

pool-1-thread-1處理任務0
pool-1-thread-2處理任務1
pool-1-thread-3處理任務2
pool-1-thread-6處理任務5
pool-1-thread-7處理任務6
pool-1-thread-4處理任務3
pool-1-thread-5處理任務4
pool-1-thread-8處理任務7
pool-1-thread-9處理任務8
pool-1-thread-10處理任務9
pool-1-thread-11處理任務10
pool-1-thread-12處理任務11
pool-1-thread-13處理任務12
pool-1-thread-14處理任務13
pool-1-thread-15處理任務14
pool-1-thread-16處理任務15
pool-1-thread-17處理任務16
pool-1-thread-18處理任務17
pool-1-thread-19處理任務18
pool-1-thread-20處理任務19
pool-1-thread-21處理任務20
pool-1-thread-25處理任務24
pool-1-thread-24處理任務23
pool-1-thread-23處理任務22
pool-1-thread-22處理任務21
pool-1-thread-26處理任務25
pool-1-thread-27處理任務26
pool-1-thread-28處理任務27
pool-1-thread-30處理任務29
pool-1-thread-29處理任務28
pool-1-thread-31處理任務30
pool-1-thread-32處理任務31
pool-1-thread-33處理任務32
pool-1-thread-38處理任務37
pool-1-thread-35處理任務34
pool-1-thread-36處理任務35
pool-1-thread-41處理任務40
pool-1-thread-34處理任務33
pool-1-thread-39處理任務38
pool-1-thread-40處理任務39
pool-1-thread-37處理任務36
pool-1-thread-42處理任務41
pool-1-thread-43處理任務42
pool-1-thread-45處理任務44
pool-1-thread-46處理任務45
pool-1-thread-44處理任務43
pool-1-thread-47處理任務46
pool-1-thread-50處理任務49
pool-1-thread-48處理任務47
pool-1-thread-49處理任務48

程式碼中使用Executors.newCachedThreadPool()建立執行緒池，看一下的原始碼：

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

從輸出中可以看出，系統建立了50個執行緒處理任務，程式碼中使用了SynchronousQueue同步佇列，這種佇列比較特殊，放入元素必須要有另外一個執行緒去獲取這個元素，否則放入元素會失敗或者一直阻塞在那裡直到有執行緒取走，示例中任務處理休眠了指定的時間，導致已建立的工作執行緒都忙於處理任務，所以新來任務之後，將任務丟入同步佇列會失敗，丟入佇列失敗之後，會嘗試新建執行緒處理任務。使用上面的方式建立執行緒池需要注意，如果需要處理的任務比較耗時，會導致新來的任務都會建立新的執行緒進行處理，可能會導致建立非常多的執行緒，最終耗盡系統資源，觸發OOM。

PriorityBlockingQueue優先順序佇列的執行緒池

package com.itsoku.chat16;

import java.util.concurrent.*;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo3 {

    static class Task implements Runnable, Comparable<Task> {

        private int i;
        private String name;

        public Task(int i, String name) {
            this.i = i;
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "處理" + this.name);
        }

        @Override
        public int compareTo(Task o) {
            return Integer.compare(o.i, this.i);
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = new ThreadPoolExecutor(1, 1,
                60L, TimeUnit.SECONDS,
                new PriorityBlockingQueue());
        for (int i = 0; i < 10; i++) {
            String taskName = "任務" + i;
            executor.execute(new Task(i, taskName));
        }
        for (int i = 100; i >= 90; i--) {
            String taskName = "任務" + i;
            executor.execute(new Task(i, taskName));
        }
        executor.shutdown();
    }
}

輸出：

pool-1-thread-1處理任務0
pool-1-thread-1處理任務100
pool-1-thread-1處理任務99
pool-1-thread-1處理任務98
pool-1-thread-1處理任務97
pool-1-thread-1處理任務96
pool-1-thread-1處理任務95
pool-1-thread-1處理任務94
pool-1-thread-1處理任務93
pool-1-thread-1處理任務92
pool-1-thread-1處理任務91
pool-1-thread-1處理任務90
pool-1-thread-1處理任務9
pool-1-thread-1處理任務8
pool-1-thread-1處理任務7
pool-1-thread-1處理任務6
pool-1-thread-1處理任務5
pool-1-thread-1處理任務4
pool-1-thread-1處理任務3
pool-1-thread-1處理任務2
pool-1-thread-1處理任務1

輸出中，除了第一個任務，其他任務按照優先順序高低按順序處理。原因在於：建立執行緒池的時候使用了優先順序佇列，進入佇列中的任務會進行排序，任務的先後順序由Task中的i變數決定。向PriorityBlockingQueue加入元素的時候，內部會呼叫程式碼中Task的compareTo方法決定元素的先後順序。

自定義建立執行緒的工廠

給執行緒池中執行緒起一個有意義的名字，在系統出現問題的時候，通過執行緒堆疊資訊可以更容易發現系統中問題所在。自定義建立工廠需要實現java.util.concurrent.ThreadFactory介面中的Thread newThread(Runnable r)方法，引數為傳入的任務，需要返回一個工作執行緒。

示例程式碼：

package com.itsoku.chat16;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * <b>description</b>： <br>
 * <b>time</b>：2019/7/28 21:01 <br>
 * <b>author</b>：ready likun_557@163.com
 */
public class Demo4 {
    static AtomicInteger threadNum = new AtomicInteger(1);

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                60L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10), r -> {
            Thread thread = new Thread(r);
            thread.setName("自定義執行緒-" + threadNum.getAndIncrement());
            return thread;
        });
        for (int i = 0; i < 5; i++) {
            String taskName = "任務-" + i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "處理" + taskName);
            });
        }
        executor.shutdown();
    }
}

輸出：

自定義執行緒-1處理任務-0
自定義執行緒-3處理任務-2
自定義執行緒-2處理任務-1
自定義執行緒-4處理任務-3
自定義執行緒-5處理任務-4

程式碼中在任務中輸出了當前執行緒的名稱，可以看到是我們自定義的名稱。

通過jstack檢視執行緒的堆疊資訊，也可以看到我們自定義的名稱，我們可以將程式碼中executor.shutdown();先給註釋掉讓程式先不退出，然後通過jstack檢視，如下：

跟著阿里p7一起學java高併發 - 第18天：玩轉java執行緒池，這一篇就夠了

4種常見飽和策略

當執行緒池中佇列已滿，並且執行緒池已達到最大執行緒數，執行緒池會將任務傳遞給飽和策略進行處理。這些策略都實現了RejectedExecutionHandler介面。介面中有個方法：

void rejectedExecution(Runnable r, ThreadPoolExecutor executor)

引數說明：

r：需要執行的任務

executor：當前執行緒池物件

JDK中提供了4種常見的飽和策略:

AbortPolicy：直接丟擲異常

CallerRunsPolicy：在當前呼叫者的執行緒中執行任務，即隨丟來的任務，由他自己去處理

DiscardOldestPolicy：丟棄佇列中最老的一個任務，即丟棄佇列頭部的一個任務，然後執行當前傳入的任務

DiscardPolicy：不處理，直接丟棄掉，方法內部為空

自定義飽和策略

需要實現RejectedExecutionHandler介面。任務無法處理的時候，我們想記錄一下日誌，我們需要自定義一個飽和策略，示例程式碼：

package com.itsoku.chat16;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo5 {
    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "處理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "Task{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,
                1,
                60L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                Executors.defaultThreadFactory(),
                (r, executors) -> {
                    //自定義飽和策略
                    //記錄一下無法處理的任務
                    System.out.println("無法處理的任務：" + r.toString());
                });
        for (int i = 0; i < 5; i++) {
            executor.execute(new Task("任務-" + i));
        }
        executor.shutdown();
    }
}

輸出：

無法處理的任務：Task{name='任務-2'}
無法處理的任務：Task{name='任務-3'}
pool-1-thread-1處理任務-0
無法處理的任務：Task{name='任務-4'}
pool-1-thread-1處理任務-1

輸出結果中可以看到有3個任務進入了飽和策略中，記錄了任務的日誌，對於無法處理多工，我們最好能夠記錄一下，讓開發人員能夠知道。任務進入了飽和策略，說明執行緒池的配置可能不是太合理，或者機器的效能有限，需要做一些優化調整。

執行緒池中的2個關閉方法

執行緒池提供了2個關閉方法：shutdown和shutdownNow，當呼叫者兩個方法之後，執行緒池會遍歷內部的工作執行緒，然後呼叫每個工作執行緒的interrrupt方法給執行緒傳送中斷訊號，內部如果無法響應中斷訊號的可能永遠無法終止，所以如果內部有無線迴圈的，最好在迴圈內部檢測一下執行緒的中斷訊號，合理的退出。呼叫者兩個方法中任意一個，執行緒池的isShutdown方法就會返回true，當所有的任務執行緒都關閉之後，才表示執行緒池關閉成功，這時呼叫isTerminaed方法會返回true。

呼叫shutdown方法之後，執行緒池將不再介面新任務，內部會將所有已提交的任務處理完畢，處理完畢之後，工作執行緒自動退出。

而呼叫shutdownNow方法後，執行緒池會將還未處理的（在隊裡等待處理的任務）任務移除，將正在處理中的處理完畢之後，工作執行緒自動退出。

至於呼叫哪個方法來關閉執行緒，應該由提交到執行緒池的任務特性決定，多數情況下呼叫shutdown方法來關閉執行緒池，如果任務不一定要執行完，則可以呼叫shutdownNow方法。

擴充套件執行緒池

雖然jdk提供了ThreadPoolExecutor這個高效能執行緒池，但是如果我們自己想在這個執行緒池上面做一些擴充套件，比如，監控每個任務執行的開始時間，結束時間，或者一些其他自定義的功能，我們應該怎麼辦？

這個jdk已經幫我們想到了，ThreadPoolExecutor內部提供了幾個方法beforeExecute、afterExecute、terminated，可以由開發人員自己去這些方法。看一下執行緒池內部的原始碼：

try {
    beforeExecute(wt, task);//任務執行之前呼叫的方法
    Throwable thrown = null;
    try {
        task.run();
    } catch (RuntimeException x) {
        thrown = x;
        throw x;
    } catch (Error x) {
        thrown = x;
        throw x;
    } catch (Throwable x) {
        thrown = x;
        throw new Error(x);
    } finally {
        afterExecute(task, thrown);//任務執行完畢之後呼叫的方法
    }
} finally {
    task = null;
    w.completedTasks++;
    w.unlock();
}

beforeExecute：任務執行之前呼叫的方法，有2個引數，第1個引數是執行任務的執行緒，第2個引數是任務

protected void beforeExecute(Thread t, Runnable r) { }

afterExecute：任務執行完成之後呼叫的方法，2個引數，第1個參數列示任務，第2個參數列示任務執行時的異常資訊，如果無異常，第二個引數為null

protected void afterExecute(Runnable r, Throwable t) { }

terminated：執行緒池最終關閉之後呼叫的方法。所有的工作執行緒都退出了，最終執行緒池會退出，退出時呼叫該方法

示例程式碼：

package com.itsoku.chat16;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 跟著阿里p7學併發，微信公眾號：javacode2018
 */
public class Demo6 {
    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "處理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "Task{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,
                10,
                60L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                Executors.defaultThreadFactory(),
                (r, executors) -> {
                    //自定義飽和策略
                    //記錄一下無法處理的任務
                    System.out.println("無法處理的任務：" + r.toString());
                }) {
            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println(System.currentTimeMillis() + "," + t.getName() + ",開始執行任務:" + r.toString());
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + ",任務:" + r.toString() + "，執行完畢!");
            }

            @Override
            protected void terminated() {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，關閉執行緒池!");
            }
        };
        for (int i = 0; i < 10; i++) {
            executor.execute(new Task("任務-" + i));
        }
        TimeUnit.SECONDS.sleep(1);
        executor.shutdown();
    }
}

輸出：

1564324574847,pool-1-thread-1,開始執行任務:Task{name='任務-0'}
1564324574850,pool-1-thread-3,開始執行任務:Task{name='任務-2'}
pool-1-thread-3處理任務-2
1564324574849,pool-1-thread-2,開始執行任務:Task{name='任務-1'}
pool-1-thread-2處理任務-1
1564324574848,pool-1-thread-5,開始執行任務:Task{name='任務-4'}
pool-1-thread-5處理任務-4
1564324574848,pool-1-thread-4,開始執行任務:Task{name='任務-3'}
pool-1-thread-4處理任務-3
1564324574850,pool-1-thread-7,開始執行任務:Task{name='任務-6'}
pool-1-thread-7處理任務-6
1564324574850,pool-1-thread-6,開始執行任務:Task{name='任務-5'}
1564324574851,pool-1-thread-8,開始執行任務:Task{name='任務-7'}
pool-1-thread-8處理任務-7
pool-1-thread-1處理任務-0
pool-1-thread-6處理任務-5
1564324574851,pool-1-thread-10,開始執行任務:Task{name='任務-9'}
pool-1-thread-10處理任務-9
1564324574852,pool-1-thread-9,開始執行任務:Task{name='任務-8'}
pool-1-thread-9處理任務-8
1564324576851,pool-1-thread-2,任務:Task{name='任務-1'}，執行完畢!
1564324576851,pool-1-thread-3,任務:Task{name='任務-2'}，執行完畢!
1564324576852,pool-1-thread-1,任務:Task{name='任務-0'}，執行完畢!
1564324576852,pool-1-thread-4,任務:Task{name='任務-3'}，執行完畢!
1564324576852,pool-1-thread-8,任務:Task{name='任務-7'}，執行完畢!
1564324576852,pool-1-thread-7,任務:Task{name='任務-6'}，執行完畢!
1564324576852,pool-1-thread-5,任務:Task{name='任務-4'}，執行完畢!
1564324576853,pool-1-thread-6,任務:Task{name='任務-5'}，執行完畢!
1564324576853,pool-1-thread-10,任務:Task{name='任務-9'}，執行完畢!
1564324576853,pool-1-thread-9,任務:Task{name='任務-8'}，執行完畢!
1564324576853,pool-1-thread-9，關閉執行緒池!

從輸出結果中可以看到，每個需要執行的任務列印了3行日誌，執行前由執行緒池的beforeExecute列印，執行時會呼叫任務的run方法，任務執行完畢之後，會呼叫執行緒池的afterExecute方法，從每個任務的首尾2條日誌中可以看到每個任務耗時2秒左右。執行緒池最終關閉之後呼叫了terminated方法。

合理地配置執行緒池

要想合理的配置執行緒池，需要先分析任務的特性，可以衝一下幾個角度分析：

任務的性質：CPU密集型任務、IO密集型任務和混合型任務
任務的優先順序：高、中、低
任務的執行時間：長、中、短
任務的依賴性：是否依賴其他的系統資源，如資料庫連線。

性質不同任務可以用不同規模的執行緒池分開處理。CPU密集型任務應該儘可能小的執行緒，如配置cpu數量+1個執行緒的執行緒池。由於IO密集型任務並不是一直在執行任務，不能讓cpu閒著，則應配置儘可能多的執行緒，如：cup數量*2。混合型的任務，如果可以拆分，將其拆分成一個CPU密集型任務和一個IO密集型任務，只要這2個任務執行的時間相差不是太大，那麼分解後執行的吞吐量將高於序列執行的吞吐量。可以通過Runtime.getRuntime().availableProcessors()方法獲取cpu數量。優先順序不同任務可以對執行緒池採用優先順序佇列來處理，讓優先順序高的先執行。

使用佇列的時候建議使用有界佇列，有界佇列增加了系統的穩定性，如果採用無解佇列，任務太多的時候可能導致系統OOM，直接讓系統當機。

執行緒池中執行緒數量的配置

執行緒池彙匯流排程大小對系統的效能有一定的影響，我們的目標是希望系統能夠發揮最好的效能，過多或者過小的執行緒數量無法有訊息的使用機器的效能。咋Java Concurrency inPractice書中給出了估算執行緒池大小的公式：

Ncpu = CUP的數量
Ucpu = 目標CPU的使用率，0<=Ucpu<=1
W/C = 等待時間與計算時間的比例
為儲存處理器達到期望的使用率，最有的執行緒池的大小等於：
Nthreads = Ncpu × Ucpu × (1+W/C)

一些使用建議

在《阿里巴巴java開發手冊》中指出了執行緒資源必須通過執行緒池提供，不允許在應用中自行顯示的建立執行緒，這樣一方面是執行緒的建立更加規範，可以合理控制開闢執行緒的數量；另一方面執行緒的細節管理交給執行緒池處理，優化了資源的開銷。而執行緒池不允許使用Executors去建立，而要通過ThreadPoolExecutor方式，這一方面是由於jdk中Executor框架雖然提供瞭如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等建立執行緒池的方法，但都有其侷限性，不夠靈活；另外由於前面幾種方法內部也是通過ThreadPoolExecutor方式實現，使用ThreadPoolExecutor有助於大家明確執行緒池的執行規則，建立符合自己的業務場景需要的執行緒池，避免資源耗盡的風險。

java高併發系列

高併發系列連載中，感興趣的加我微信itsoku，一起交流，關注公眾號：路人甲Java，每天獲取最新連載文章！

跟著阿里p7一起學java高併發 - 第18天：玩轉java執行緒池，這一篇就夠了

java高併發系列 - 第23天：JUC中原子類，一篇就夠了
2019-08-07
Java
面試題-關於Java執行緒池一篇文章就夠了
2019-12-16
面試題Java執行緒
快速瞭解Java多執行緒，有這一篇就夠了
2020-10-29
Java執行緒
【萬字圖文-原創】 | 學會Java中的執行緒池，這一篇也許就夠了！
2020-05-24
Java執行緒
Java併發系列 — 執行緒池
2019-01-04
Java執行緒
Java併發——執行緒池ThreadPoolExecutor
2018-08-30
Java執行緒thread
Java高階特性泛型看這一篇就夠了
2020-09-21
Java泛型
Java 集合看這一篇就夠了
2020-10-15
Java
Java多執行緒18：執行緒池
2015-10-06
Java執行緒
java多執行緒與併發 - 執行緒池詳解
2018-03-13
Java執行緒
Java併發基礎（2）------執行緒池
2019-06-10
Java執行緒
java併發程式設計——執行緒池
2019-02-12
Java程式設計執行緒
和朱曄一起復習Java併發（一）：執行緒池
2019-07-13
Java執行緒
Java 併發：執行緒、執行緒池和執行器全面教程
2024-03-18
Java執行緒
Java多執行緒超級詳解(只看這篇就夠了)
2022-08-11
Java執行緒
java執行緒池趣味事：這不是執行緒池
2021-02-20
Java執行緒
深入理解Java多執行緒與併發框（第⑪篇）——執行緒池引數
2020-03-31
Java執行緒
Java併發程式設計學習筆記----執行緒池
2020-04-05
Java程式設計筆記執行緒
學好執行緒池，搞定高併發！（文末福利）
2023-03-31
執行緒
【重學Java】多執行緒進階（執行緒池、原子性、併發工具類）
2021-07-16
Java執行緒
Java併發之執行緒池系列 (2) 使用ThreadPoolExecutor構造執行緒池
2019-04-01
Java執行緒thread
Java併發之執行緒池系列 (1) 讓多執行緒不再坑爹的執行緒池
2019-03-31
Java執行緒
Java 執行緒池學習
2012-08-01
Java執行緒
Java 併發和多執行緒(一) Java併發性和多執行緒介紹[轉]
2016-01-15
Java執行緒
學Nginx,這一篇就夠了
2020-09-25
Nginx
Java併發程式設計：執行緒池ThreadPoolExecutor
2020-05-19
Java程式設計執行緒thread
Java 併發程式設計 | 執行緒池詳解
2019-05-15
Java程式設計執行緒
java併發程式設計：執行緒池的使用
2018-04-13
Java程式設計執行緒
【JAVA併發第一篇】Java的程式與執行緒
2020-12-07
Java執行緒
《java學習三》併發程式設計 -------執行緒池原理剖析
2019-03-23
Java程式設計執行緒
Java併發之執行緒池ThreadPoolExecutor原始碼分析學習
2018-09-05
Java執行緒thread原始碼
關於Jmeter執行緒組的設定，看這一篇就夠了
2021-11-28
JMeter執行緒
Java高併發與多執行緒（一）-----概念
2021-01-12
Java執行緒
Java安全第一篇｜反射看這一篇就夠了
2022-03-21
Java反射
Java執行緒池二：執行緒池原理
2020-12-20
Java執行緒
JAVA多執行緒併發
2020-12-21
Java執行緒
java併發與執行緒
2017-08-05
Java執行緒
Java執行緒池
2020-09-23
Java執行緒

跟著阿里p7一起學java高併發 - 第18天：玩轉java執行緒池，這一篇就夠了

java中的執行緒池，這一篇就夠了

本文主要內容

什麼是執行緒池

執行緒池實現原理

java中的執行緒池

執行緒池使用的簡單示例

執行緒池中常見5種工作佇列

SynchronousQueue佇列的執行緒池

PriorityBlockingQueue優先順序佇列的執行緒池

自定義建立執行緒的工廠

4種常見飽和策略

自定義飽和策略

執行緒池中的2個關閉方法

擴充套件執行緒池

合理地配置執行緒池

執行緒池中執行緒數量的配置

一些使用建議

java高併發系列

相關文章