線程池是多線程編程中的核心概念，簡單來說就是一組可以執(zhí)行任務的空閑線程。

首先，我們了解一下多線程框架模型，明白為什么需要線程池。

線程是在一個進程中可以執(zhí)行一系列指令的執(zhí)行環(huán)境，或稱運行程序。多線程編程指的是用多個線程并行執(zhí)行多個任務。當然，JVM 對多線程有良好的支持。

盡管這帶來了諸多優(yōu)勢，首當其沖的就是程序性能提高，但多線程編程也有缺點 —— 增加了代碼復雜度、同步問題、非預期結(jié)果和增加創(chuàng)建線程的開銷。

在這篇文章中，我們來了解一下如何使用 Java 線程池來緩解這些問題。

為什么使用線程池？

創(chuàng)建并開啟一個線程開銷很大。如果我們每次需要執(zhí)行任務時重復這個步驟，那將會是一筆巨大的性能開銷，這也是我們希望通過多線程解決的問題。

為了更好理解創(chuàng)建和開啟一個線程的開銷，讓我們來看一看 JVM 在后臺做了哪些事：

• 為線程棧分配內(nèi)存，保存每個線程方法調(diào)用的棧幀。
• 每個棧幀包括本地變量數(shù)組、返回值、操作棧和常量池
• 一些 JVM 支持本地方法，也將分配本地方法棧
• 每個線程獲得一個程序計數(shù)器，標識處理器正在執(zhí)行哪條指令
• 系統(tǒng)創(chuàng)建本地線程，與 Java 線程對應
• 和線程相關(guān)的描述符被添加到 JVM 內(nèi)部數(shù)據(jù)結(jié)構(gòu)
• 線程共享堆和方法區(qū)

當然，這些步驟的具體細節(jié)取決于 JVM 和操作系統(tǒng)。

另外，更多的線程意味著更多工作量，系統(tǒng)需要調(diào)度和決定哪個線程接下來可以訪問資源。

線程池通過減少需要的線程數(shù)量并管理線程生命周期，來幫助我們緩解性能問題。

本質(zhì)上，線程在我們使用前一直保存在線程池中，在執(zhí)行完任務之后，線程會返回線程池等待下次使用。這種機制在執(zhí)行很多小任務的系統(tǒng)中十分有用。

Java 線程池

Java 通過 executor 對象來實現(xiàn)自己的線程池模型。可以使用 executor 接口或其他線程池的實現(xiàn)，它們都允許細粒度的控制。

java.util.concurrent 包中有以下接口：

• Executor —— 執(zhí)行任務的簡單接口
• ExecutorService —— 一個較復雜的接口，包含額外方法來管理任務和 executor 本身
• ScheduledExecutorService —— 擴展自 ExecutorService，增加了執(zhí)行任務的調(diào)度方法

除了這些接口，這個包中也提供了 Executors 類直接獲取實現(xiàn)了這些接口的 executor 實例

一般來說，一個 Java 線程池包含以下部分：

• 工作線程的池子，負責管理線程
• 線程工廠，負責創(chuàng)建新線程
• 等待執(zhí)行的任務隊列

在下面的章節(jié)，讓我們仔細看一看 Java 類和接口如何為線程池提供支持。

Executors 類和 Executor 接口

Executors 類包含工廠方法創(chuàng)建不同類型的線程池，Executor 是個簡單的線程池接口，只有一個 execute() 方法。

我們通過一個例子來結(jié)合使用這兩個類(接口)，首先創(chuàng)建一個單線程的線程池，然后用它執(zhí)行一個簡單的語句：

Executor executor = Executors.newSingleThreadExecutor();
executor.execute(() -> System.out.println("Single thread pool test"));

注意語句寫成了 lambda 表達式，會被自動推斷成 Runnable 類型。

如果有工作線程可用，execute() 方法將執(zhí)行語句，否則就把 Runnable 任務放進隊列，等待線程可用。

基本上，executor 代替了顯式創(chuàng)建和管理線程。

Executors 類里的工廠方法可以創(chuàng)建很多類型的線程池：

• newSingleThreadExecutor()：包含單個線程和無界隊列的線程池，同一時間只能執(zhí)行一個任務
• newFixedThreadPool()：包含固定數(shù)量線程并共享無界隊列的線程池；當所有線程處于工作狀態(tài)，有新任務提交時，任務在隊列中等待，直到一個線程變?yōu)榭捎脿顟B(tài)
• newCachedThreadPool()：只有需要時創(chuàng)建新線程的線程池
• newWorkStealingThreadPool()：基于工作竊取（work-stealing）算法的線程池，后面章節(jié)詳細說明

接下來，讓我們看一下 ExecutorService 接口提供了哪些新功能

ExecutorService

創(chuàng)建 ExecutorService 方式之一便是通過 Excutors 類的工廠方法。

ExecutorService executor = Executors.newFixedThreadPool(10);

Besides the execute() method, this interface also defines a similar submit() method that can return a Future object:

除了 execute() 方法，接口也定義了相似的 submit() 方法，這個方法可以返回一個 Future 對象。

Callable<Double> callableTask = () -> {
    return employeeService.calculateBonus(employee);
};
Future<Double> future = executor.submit(callableTask);
// execute other operations
try {
    if (future.isDone()) {
        double result = future.get();
    }
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

從上面的例子可以看到，Future 接口可以返回 Callable 類型任務的結(jié)果，而且能顯示任務的執(zhí)行狀態(tài)。

當沒有任務等待執(zhí)行時，ExecutorService 并不會自動銷毀，所以你可以使用 shutdown() 或 shutdownNow() 來顯式關(guān)閉它。

executor.shutdown();

ScheduledExecutorService

這是 ExecutorService 的一個子接口，增加了調(diào)度任務的方法。

ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);

schedule() 方法的參數(shù)指定執(zhí)行的方法、延時和 TimeUnit

Future<Double> future = executor.schedule(callableTask, 2, TimeUnit.MILLISECONDS);

另外，這個接口定義了其他兩個方法：

executor.scheduleAtFixedRate(
  () -> System.out.println("Fixed Rate Scheduled"), 2, 2000, TimeUnit.MILLISECONDS);

executor.scheduleWithFixedDelay(
  () -> System.out.println("Fixed Delay Scheduled"), 2, 2000, TimeUnit.MILLISECONDS);

scheduleAtFixedRate() 方法延時 2 毫秒執(zhí)行任務，然后每 2 秒重復一次。相似的，scheduleWithFixedDelay() 方法延時 2 毫秒后執(zhí)行第一次，然后在上一次執(zhí)行完成 2 秒后再次重復執(zhí)行。

在下面的章節(jié)，我們來看一下 ExecutorService 接口的兩個實現(xiàn)：ThreadPoolExecutor 和 ForkJoinPool。

ThreadPoolExecutor

這個線程池的實現(xiàn)增加了配置參數(shù)的能力。創(chuàng)建 ThreadPoolExecutor 對象最方便的方式就是通過 Executors 工廠方法：

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);

這種情況下，線程池按照默認值預配置了參數(shù)。線程數(shù)量由以下參數(shù)控制：

• corePoolSize 和 maximumPoolSize：表示線程數(shù)量的范圍
• keepAliveTime：決定了額外線程存活時間

我們深入了解一下這些參數(shù)如何使用。

當一個任務被提交時，如果執(zhí)行中的線程數(shù)量小于 corePoolSize，一個新的線程被創(chuàng)建。如果運行的線程數(shù)量大于 corePoolSize，但小于 maximumPoolSize，并且任務隊列已滿時，依然會創(chuàng)建新的線程。如果多于 corePoolSize 的線程空閑時間超過 keepAliveTime，它們會被終止。

上面那個例子中，newFixedThreadPool() 方法創(chuàng)建的線程池，corePoolSize=maximumPoolSize=10 并且 keepAliveTime 為 0 秒。

如果你使用 newCachedThreadPool() 方法，創(chuàng)建的線程池 maximumPoolSize 為 Integer.MAX_VALUE，并且 keepAliveTime 為 60 秒。

ThreadPoolExecutor cachedPoolExecutor 
  = (ThreadPoolExecutor) Executors.newCachedThreadPool();

The parameters can also be set through a constructor or through setter methods:

這些參數(shù)也可以通過構(gòu)造函數(shù)或setter方法設(shè)置：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
  4, 6, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()
);
executor.setMaximumPoolSize(8);

ThreadPoolExecutor 的一個子類便是 ScheduledThreadPoolExecutor，它實現(xiàn)了 ScheduledExecutorService 接口。你可以通過 newScheduledThreadPool() 工廠方法來創(chuàng)建這種類型的線程池。

ScheduledThreadPoolExecutor executor 
  = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(5);

上面語句創(chuàng)建了一個線程池，corePoolSize 為 5，maximumPoolSize 無限制，keepAliveTime 為 0 秒。

ForkJoinPool

另一個線程池的實現(xiàn)是 ForkJoinPool 類。它實現(xiàn)了 ExecutorService 接口，并且是 Java 7 中 fork/join 框架的重要組件。

fork/join 框架基于“工作竊取算法”。簡而言之，意思就是執(zhí)行完任務的線程可以從其他運行中的線程“竊取”工作。

ForkJoinPool 適用于任務創(chuàng)建子任務的情況，或者外部客戶端創(chuàng)建大量小任務到線程池。

這種線程池的工作流程如下：

• 創(chuàng)建 ForkJoinTask 子類
• 根據(jù)某種條件將任務切分成子任務
• 調(diào)用執(zhí)行任務
• 將任務結(jié)果合并
• 實例化對象并添加到池中

創(chuàng)建一個 ForkJoinTask，你可以選擇 RecursiveAction 或 RecursiveTask 這兩個子類，后者有返回值。

我們來實現(xiàn)一個繼承 RecursiveTask 的類，計算階乘，并把任務根據(jù)閾值劃分成子任務。

public class FactorialTask extends RecursiveTask<BigInteger> {
    private int start = 1;
    private int n;
    private static final int THRESHOLD = 20;

    // standard constructors

    @Override
    protected BigInteger compute() {
        if ((n - start) >= THRESHOLD) {
            return ForkJoinTask.invokeAll(createSubtasks())
              .stream()
              .map(ForkJoinTask::join)
              .reduce(BigInteger.ONE, BigInteger::multiply);
        } else {
            return calculate(start, n);
        }
    }
}

這個類需要實現(xiàn)的主要方法就是重寫 compute() 方法，用于合并每個子任務的結(jié)果。

具體劃分任務邏輯在 createSubtasks() 方法中：

private Collection<FactorialTask> createSubtasks() {
    List<FactorialTask> dividedTasks = new ArrayList<>();
    int mid = (start + n) / 2;
    dividedTasks.add(new FactorialTask(start, mid));
    dividedTasks.add(new FactorialTask(mid + 1, n));
    return dividedTasks;
}

最后，calculate() 方法包含一定范圍內(nèi)的乘數(shù)。

private BigInteger calculate(int start, int n) {
    return IntStream.rangeClosed(start, n)
      .mapToObj(BigInteger::valueOf)
      .reduce(BigInteger.ONE, BigInteger::multiply);
}

接下來，任務可以添加到線程池：

ForkJoinPool pool = ForkJoinPool.commonPool();
BigInteger result = pool.invoke(new FactorialTask(100));

ThreadPoolExecutor 與 ForkJoinPool 對比

初看上去，似乎 fork/join 框架帶來性能提升。但是這取決于你所解決問題的類型。

當選擇線程池時，非常重要的一點是牢記創(chuàng)建、管理線程以及線程間切換執(zhí)行會帶來的開銷。

ThreadPoolExecutor 可以控制線程數(shù)量和每個線程執(zhí)行的任務。這很適合你需要在不同的線程上執(zhí)行少量巨大的任務。

相比較而言，ForkJoinPool 基于線程從其他線程“竊取”任務。正因如此，當任務可以分割成小任務時可以提高效率。

為了實現(xiàn)工作竊取算法，fork/join 框架使用兩種隊列：

• 包含所有任務的主要隊列
• 每個線程的任務隊列

當線程執(zhí)行完自己任務隊列中的任務，它們試圖從其他隊列獲取任務。為了使這一過程更加高效，線程任務隊列使用雙端隊列（double ended queue）數(shù)據(jù)結(jié)構(gòu)，一端與線程交互，另一端用于“竊取”任務。

來自The H Developer的圖很好的表現(xiàn)出了這一過程：

和這種模型相比，ThreadPoolExecutor 只使用一個主要隊列。

最后要注意的一點 ForkJoinPool 只適用于任務可以創(chuàng)建子任務。否則它和 ThreadPoolExecutor 沒區(qū)別，甚至開銷更大。

跟蹤線程池的執(zhí)行

現(xiàn)在我們對 Java 線程池生態(tài)系統(tǒng)有了基本的了解，讓我們通過一個使用了線程池的應用，來看一看執(zhí)行中到底發(fā)生了什么。

通過在 FactorialTask 的構(gòu)造函數(shù)和 calculate() 方法中加入日志語句，你可以看到下面調(diào)用序列：

13:07:33.123 [main] INFO ROOT - New FactorialTask Created
13:07:33.123 [main] INFO ROOT - New FactorialTask Created
13:07:33.123 [main] INFO ROOT - New FactorialTask Created
13:07:33.123 [main] INFO ROOT - New FactorialTask Created
13:07:33.123 [ForkJoinPool.commonPool-worker-1] INFO ROOT - New FactorialTask Created
13:07:33.123 [ForkJoinPool.commonPool-worker-1] INFO ROOT - New FactorialTask Created
13:07:33.123 [main] INFO ROOT - New FactorialTask Created
13:07:33.123 [main] INFO ROOT - New FactorialTask Created
13:07:33.123 [main] INFO ROOT - Calculate factorial from 1 to 13
13:07:33.123 [ForkJoinPool.commonPool-worker-1] INFO ROOT - New FactorialTask Created
13:07:33.123 [ForkJoinPool.commonPool-worker-2] INFO ROOT - New FactorialTask Created
13:07:33.123 [ForkJoinPool.commonPool-worker-1] INFO ROOT - New FactorialTask Created
13:07:33.123 [ForkJoinPool.commonPool-worker-2] INFO ROOT - New FactorialTask Created
13:07:33.123 [ForkJoinPool.commonPool-worker-1] INFO ROOT - Calculate factorial from 51 to 63
13:07:33.123 [ForkJoinPool.commonPool-worker-2] INFO ROOT - Calculate factorial from 76 to 88
13:07:33.123 [ForkJoinPool.commonPool-worker-3] INFO ROOT - Calculate factorial from 64 to 75
13:07:33.163 [ForkJoinPool.commonPool-worker-3] INFO ROOT - New FactorialTask Created
13:07:33.163 [main] INFO ROOT - Calculate factorial from 14 to 25
13:07:33.163 [ForkJoinPool.commonPool-worker-3] INFO ROOT - New FactorialTask Created
13:07:33.163 [ForkJoinPool.commonPool-worker-2] INFO ROOT - Calculate factorial from 89 to 100
13:07:33.163 [ForkJoinPool.commonPool-worker-3] INFO ROOT - Calculate factorial from 26 to 38
13:07:33.163 [ForkJoinPool.commonPool-worker-3] INFO ROOT - Calculate factorial from 39 to 50

你可以看到創(chuàng)建了很多任務，但只有 3 個工作線程 —— 所以任務通過線程池被可用線程處理。

也可以看到在放到執(zhí)行池之前，主線程中對象如何被創(chuàng)建。

使用 Prefix 這一類可視化的日志工具是一個很棒的方式來探索和理解運行時的線程池。

記錄線程池日志的核心便是保證在日志信息中方便辨識線程名字。Log4J2 通過使用布局能夠很好完成這種工作。

使用線程池的潛在風險

盡管線程池有巨大優(yōu)勢，你在使用中仍會遇到一些問題，比如：

• 用的線程池過大或過�。喝绻�線程池包含太多線程，會明顯的影響應用的性能；另一方面，線程池太小并不能帶來所期待的性能提升。
• 正如其他多線程情形一樣，死鎖也會發(fā)生。舉個例子，一個任務可能等待另一個任務完成，而后者并沒有可用線程處理執(zhí)行。所以說避免任務之間的依賴是個好習慣。
• 等待執(zhí)行時間很長的任務：為了避免長時間阻塞線程，你可以指定最大等待時間，并決定過期任務是拒絕處理還是重新加入隊列。

為了降低風險，你必須根據(jù)要處理的任務，來謹慎選擇線程池的類型和參數(shù)。對你的系統(tǒng)進行壓力測試也是值得的，它可以幫你獲取真實環(huán)境下的系統(tǒng)行為數(shù)據(jù)。

結(jié)論

線程池有很大優(yōu)勢，簡單來說就是可以將任務的執(zhí)行從線程的創(chuàng)建和管理中分離。另外，如果使用得當，它們可以極大提高應用的性能。

如果你學會充分利用線程池，Java 生態(tài)系統(tǒng)好處便是其中有很多成熟穩(wěn)定的線程池實現(xiàn)。

原文鏈接： stackify 翻譯： ImportNew.com - 一杯哈希不加鹽
譯文鏈接： http://www.importnew.com/29212.html
[ 轉(zhuǎn)載請保留原文出處、譯者和譯文鏈接。]

標簽： 代碼

版權(quán)申明：本站文章部分自網(wǎng)絡(luò)，如有侵權(quán)，請聯(lián)系：west999com@outlook.com
特別注意：本站所有轉(zhuǎn)載文章言論不代表本站觀點！
本站所提供的圖片等素材，版權(quán)歸原作者所有，如需使用，請與原作者聯(lián)系。