新手也能看懂的SpringBoot非同步程式設計指南(簡單易懂)

阿新 • • 發佈：2020-11-26

通過本文你可以瞭解到下面這些知識點：

Future 模式介紹以及核心思想
核心執行緒數、最大執行緒數的區別，佇列容量代表什麼；
ThreadPoolTaskExecutor 飽和策略；
SpringBoot 非同步程式設計實戰，搞懂程式碼的執行邏輯。

Future 模式

非同步程式設計在處理耗時操作以及多工處理的場景下非常有用，我們可以更好的讓我們的系統利用好機器的 CPU 和記憶體，提高它們的利用率。多執行緒設計模式有很多種，Future模式是多執行緒開發中非常常見的一種設計模式，本文也是基於這種模式來說明 SpringBoot 對於非同步程式設計的知識。

實戰之前我先簡單介紹一下 Future 模式的核心思想吧！。

Future 模式的核心思想是非同步呼叫。當我們執行一個方法時，假如這個方法中有多個耗時的任務需要同時去做，而且又不著急等待這個結果時可以讓客戶端立即返回然後，後臺慢慢去計算任務。當然你也可以選擇等這些任務都執行完了，再返回給客戶端。這個在 Java 中都有很好的支援，我在後面的示例程式中會詳細對比這兩種方式的區別。

SpringBoot 非同步程式設計實戰

如果我們需要在 SpringBoot 實現非同步程式設計的話，通過 Spring 提供的兩個註解會讓這件事情變的非常簡單。

@EnableAsync：通過在配置類或者Main類上加@EnableAsync開啟對非同步方法的支援。

@Async 可以作用在類上或者方法上，作用在類上代表這個類的所有方法都是非同步方法。

1. 自定義 TaskExecutor

很多人對於 TaskExecutor 不是太瞭解，所以我們花一點篇幅先介紹一下這個東西。從名字就能看出它是任務的執行者，它領導執行著執行緒來處理任務，就像司令官一樣，而我們的執行緒就好比一隻只軍隊一樣，這些軍隊可以非同步對敵人進行打擊👊。
Spring 提供了TaskExecutor介面作為任務執行者的抽象,它和java.util.concurrent包下的Executor介面很像。稍微不同的 TaskExecutor介面用到了 Java 8 的語法@FunctionalInterface宣告這個介面是一個函式式介面。

org.springframework.core.task.TaskExecutor
@FunctionalInterface
public interface TaskExecutor extends Executor {
  void execute(Runnable var1);
}

如果沒有自定義Executor, Spring 將建立一個 SimpleAsyncTaskExecutor 並使用它。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/** @author shuang.kou */
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

 private static final int CORE_POOL_SIZE = 6;
 private static final int MAX_POOL_SIZE = 10;
 private static final int QUEUE_CAPACITY = 100;

 @Bean
 public Executor taskExecutor() {
  // Spring 預設配置是核心執行緒數大小為1，最大執行緒容量大小不受限制，佇列容量也不受限制。
  ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
  // 核心執行緒數
  executor.setCorePoolSize(CORE_POOL_SIZE);
  // 最大執行緒數
  executor.setMaxPoolSize(MAX_POOL_SIZE);
  // 佇列大小
  executor.setQueueCapacity(QUEUE_CAPACITY);
  // 當最大池已滿時，此策略保證不會丟失任務請求，但是可能會影響應用程式整體效能。
  executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
  executor.setThreadNamePrefix("My ThreadPoolTaskExecutor-");
  executor.initialize();
  return executor;
 }
}

ThreadPoolTaskExecutor 常見概念：

Core Pool Size : 核心執行緒數執行緒數定義了最小可以同時執行的執行緒數量。
Queue Capacity : 當新任務來的時候會先判斷當前執行的執行緒數量是否達到核心執行緒數，如果達到的話，信任就會被存放在佇列中。
Maximum Pool Size : 當佇列中存放的任務達到佇列容量的時候，當前可以同時執行的執行緒數量變為最大執行緒數。

一般情況下不會將佇列大小設為：Integer.MAX_VALUE,也不會將核心執行緒數和最大執行緒數設為同樣的大小，這樣的話最大執行緒數的設定都沒什麼意義了，你也無法確定當前 CPU 和記憶體利用率具體情況如何。

如果佇列已滿並且當前同時執行的執行緒數達到最大執行緒數的時候，如果再有新任務過來會發生什麼呢？

Spring 預設使用的是 ThreadPoolExecutor.AbortPolicy。在Spring的預設情況下，ThreadPoolExecutor 將丟擲 RejectedExecutionException 來拒絕新來的任務，這代表你將丟失對這個任務的處理。對於可伸縮的應用程式，建議使用 ThreadPoolExecutor.CallerRunsPolicy。當最大池被填滿時，此策略為我們提供可伸縮佇列。

ThreadPoolTaskExecutor 飽和策略定義:

如果當前同時執行的執行緒數量達到最大執行緒數量時，ThreadPoolTaskExecutor 定義一些策略:

ThreadPoolExecutor.AbortPolicy：丟擲 RejectedExecutionException來拒絕新任務的處理。
ThreadPoolExecutor.CallerRunsPolicy：呼叫執行自己的執行緒執行任務。您不會任務請求。但是這種策略會降低對於新任務提交速度，影響程式的整體效能。另外，這個策略喜歡增加佇列容量。如果您的應用程式可以承受此延遲並且你不能任務丟棄任何一個任務請求的話，你可以選擇這個策略。
ThreadPoolExecutor.DiscardPolicy：不處理新任務，直接丟棄掉。
ThreadPoolExecutor.DiscardOldestPolicy：此策略將丟棄最早的未處理的任務請求。

2. 編寫一個非同步的方法

下面模擬一個查詢對應字元開頭電影的方法，我們給這個方法加上了@Async註解來告訴 Spring 它是一個非同步的方法。另外，這個方法的返回值 CompletableFuture.completedFuture(results)這代表我們需要返回結果，也就是說程式必須把任務執行完成之後再返回給使用者。

請留意completableFutureTask方法中的第一行列印日誌這句程式碼，後面分析程式中會用到，很重要！

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/** @author shuang.kou */
@Service
public class AsyncService {

 private static final Logger logger = LoggerFactory.getLogger(AsyncService.class);

 private List<String> movies =
   new ArrayList<>(
     Arrays.asList(
       "Forrest Gump",
       "Titanic",
       "Spirited Away",
       "The Shawshank Redemption",
       "Zootopia",
       "Farewell ",
       "Joker",
       "Crawl"));

 /** 示範使用：找到特定字元/字串開頭的電影 */
 @Async
 public CompletableFuture<List<String>> completableFutureTask(String start) {
  // 列印日誌
  logger.warn(Thread.currentThread().getName() + "start this task!");
  // 找到特定字元/字串開頭的電影
  List<String> results =
    movies.stream().filter(movie -> movie.startsWith(start)).collect(Collectors.toList());
  // 模擬這是一個耗時的任務
  try {
   Thread.sleep(1000L);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  //返回一個已經用給定值完成的新的CompletableFuture。
  return CompletableFuture.completedFuture(results);
 }
}

3. 測試編寫的非同步方法

/** @author shuang.kou */
@RestController
@RequestMapping("/async")
public class AsyncController {
 @Autowired 
 AsyncService asyncService;

 @GetMapping("/movies")
 public String completableFutureTask() throws ExecutionException, InterruptedException {
  //開始時間
  long start = System.currentTimeMillis();
  // 開始執行大量的非同步任務
  List<String> words = Arrays.asList("F", "T", "S", "Z", "J", "C");
  List<CompletableFuture<List<String>>> completableFutureList =
    words.stream()
      .map(word -> asyncService.completableFutureTask(word))
      .collect(Collectors.toList());
  // CompletableFuture.join（）方法可以獲取他們的結果並將結果連線起來
  List<List<String>> results = completableFutureList.stream().map(CompletableFuture::join).collect(Collectors.toList());
  // 列印結果以及執行程式執行花費時間
  System.out.println("Elapsed time: " + (System.currentTimeMillis() - start));
  return results.toString();
 }
}

請求這個介面，控制檯打印出下面的內容：

2019-10-01 13:50:17.007 WARN 18793 --- [lTaskExecutor-1] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-1start this task!
2019-10-01 13:50:17.007 WARN 18793 --- [lTaskExecutor-6] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-6start this task!
2019-10-01 13:50:17.007 WARN 18793 --- [lTaskExecutor-5] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-5start this task!
2019-10-01 13:50:17.007 WARN 18793 --- [lTaskExecutor-4] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-4start this task!
2019-10-01 13:50:17.007 WARN 18793 --- [lTaskExecutor-3] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-3start this task!
2019-10-01 13:50:17.007 WARN 18793 --- [lTaskExecutor-2] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-2start this task!
Elapsed time: 1010

首先我們可以看到處理所有任務花費的時間大概是 1 s。這與我們自定義的 ThreadPoolTaskExecutor 有關，我們配置的核心執行緒數是 6 ，然後通過通過下面的程式碼模擬分配了 6 個任務給系統執行。這樣每個執行緒都會被分配到一個任務，每個任務執行花費時間是 1 s ，所以處理 6 個任務的總花費時間是 1 s。

List<String> words = Arrays.asList("F", "T", "S", "Z", "J", "C"); 
List<CompletableFuture<List<String>>> completableFutureList =
    words.stream()
      .map(word -> asyncService.completableFutureTask(word))
      .collect(Collectors.toList());

你可以自己驗證一下，試著去把核心執行緒數的數量改為 3 ，再次請求這個介面你會發現處理所有任務花費的時間大概是 2 s。

另外，從上面的執行結果可以看出，當所有任務執行完成之後才返回結果。這種情況對應於我們需要返回結果給客戶端請求的情況下，假如我們不需要返回任務執行結果給客戶端的話呢？就比如我們上傳一個大檔案到系統，上傳之後只要大檔案格式符合要求我們就上傳成功。普通情況下我們需要等待檔案上傳完畢再返回給使用者訊息，但是這樣會很慢。採用非同步的話，當用戶上傳之後就立馬返回給使用者訊息，然後系統再默默去處理上傳任務。這樣也會增加一點麻煩，因為檔案可能會上傳失敗，所以系統也需要一點機制來補償這個問題，比如當上傳遇到問題的時候，發訊息通知使用者。

下面會演示一下客戶端不需要返回結果的情況：

將completableFutureTask方法變為 void 型別

@Async
public void completableFutureTask(String start) {
 ......
 //這裡可能是系統對任務執行結果的處理，比如存入到資料庫等等......
 //doSomeThingWithResults(results);
}

Controller 程式碼修改如下：

 @GetMapping("/movies")
 public String completableFutureTask() throws ExecutionException, InterruptedException {
  // Start the clock
  long start = System.currentTimeMillis();
  // Kick of multiple, asynchronous lookups
  List<String> words = Arrays.asList("F", "T", "S", "Z", "J", "C");
    words.stream()
      .forEach(word -> asyncService.completableFutureTask(word));
  // Wait until they are all done
  // Print results, including elapsed time
  System.out.println("Elapsed time: " + (System.currentTimeMillis() - start));
  return "Done";
 }

請求這個介面，控制檯打印出下面的內容：

Elapsed time: 0
2019-10-01 14:02:44.052 WARN 19051 --- [lTaskExecutor-4] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-4start this task!
2019-10-01 14:02:44.052 WARN 19051 --- [lTaskExecutor-3] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-3start this task!
2019-10-01 14:02:44.052 WARN 19051 --- [lTaskExecutor-2] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-2start this task!
2019-10-01 14:02:44.052 WARN 19051 --- [lTaskExecutor-1] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-1start this task!
2019-10-01 14:02:44.052 WARN 19051 --- [lTaskExecutor-6] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-6start this task!
2019-10-01 14:02:44.052 WARN 19051 --- [lTaskExecutor-5] g.j.a.service.AsyncService : My ThreadPoolTaskExecutor-5start this task!

可以看到系統會直接返回給使用者結果，然後系統才真正開始執行任務。

待辦

Future vs. CompletableFuture
原始碼分析

Reference

https://spring.io/guides/gs/async-method/
https://medium.com/trendyol-tech/spring-boot-async-executor-management-with-threadpooltaskexecutor-f493903617d

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援碼農教程。

新手也能看懂的SpringBoot非同步程式設計指南(簡單易懂)

新手也能看懂的SpringBoot非同步程式設計指南(簡單易懂)

新手也能看懂的 SpringBoot 非同步程式設計指南

RocketMQ入門到入土（一）新手也能看懂的原理和實戰！

新手也能看懂得當Promise的回撥函式中返回Promise物件時執行過程

新手也能看懂的LeNet網路分類MINST資料集解析，附詳細程式碼及註解

個人學習程式設計的一些經驗傻子也能看懂的弗洛伊德演算法

小白也能看懂了的Lambda 表示式

「Netty實戰 02」手把手教你實現自己的第一個 Netty 應用!新手也能搞懂！

小白也能看懂的ArrayList的擴容機制

小白也能看懂的JDK1.8前_HashMap的擴容機制原理

無需專業知識也能看懂這篇 AED 科普

小白也能看懂！教你如何快速搭建實用的爬蟲管理平臺

小刻也能看懂的Unraid系統使用手冊：Docker篇

不是技術也能看懂雲原生

圖解SQL基礎知識，小白也能看懂的SQL文章！

程式大佬花費10個小時整理，小白也能看懂的阿里資料中臺分析

戰地2042公測Steam/Origin/Epic免費下載教程小白也能看懂

【筆記】草履蟲也能看懂的ELK搭建流程

【緊急】Log4j又發新版2.17.0，只有徹底搞懂漏洞原因，才能以不變應萬變，小白也能看懂

小白也能看懂的REDIS教學基礎篇——做一個時間窗限流就是這麼簡單

新手也能看懂的SpringBoot非同步程式設計指南(簡單易懂)

相關推薦