實戰Spring Boot 2.0系列(四) – 使用WebAsyncTask處理非同步任務

零壹技術棧發表於2019-03-02
Spring BootWeb非同步

# 前言

上文介紹了基於 @Async 註解的 非同步呼叫程式設計，本文將繼續引入 Spring Boot 的 WebAsyncTask 進行更靈活非同步任務處理，包括 非同步回撥，超時處理 和 異常處理。

實戰Spring Boot 2.0系列(四) – 使用WebAsyncTask處理非同步任務

本系列文章

  1. 實戰Spring Boot 2.0系列(一) – 使用Gradle構建Docker映象
  2. 實戰Spring Boot 2.0系列(二) – 全域性異常處理和測試
  3. 實戰Spring Boot 2.0系列(三) – 使用@Async進行非同步呼叫詳解
  4. 實戰Spring Boot 2.0系列(四) – 使用WebAsyncTask處理非同步任務
  5. 實戰Spring Boot 2.0系列(五) – Listener, Servlet, Filter和Interceptor
  6. 實戰Spring Boot 2.0系列(六) – 單機定時任務的幾種實現

正文

1. 處理執行緒和非同步執行緒

在開始下面的講解之前，在這裡先區別下兩個概念：

  1. 處理執行緒：處理執行緒 屬於 web 伺服器執行緒，負責 處理使用者請求，採用 執行緒池 管理。

  2. 非同步執行緒：非同步執行緒 屬於 使用者自定義的執行緒，可採用 執行緒池管理。

Spring 提供了對 非同步任務 API，採用 WebAsyncTask 類即可實現 非同步任務。對非同步任務設定相應的 回撥處理，如當 任務超時、異常丟擲 等。非同步任務通常非常實用，比如：當一筆訂單支付完成之後，開啟非同步任務查詢訂單的支付結果。

2. 環境準備

配置gradle依賴

利用 Spring Initializer 建立一個 gradle 專案 spring-boot-web-async-task，建立時新增相關依賴。得到的初始 build.gradle 如下：

buildscript {
    ext {
        springBootVersion = `2.0.3.RELEASE`
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: `java`
apply plugin: `eclipse`
apply plugin: `org.springframework.boot`
apply plugin: `io.spring.dependency-management`

group = `io.ostenant.springboot.sample`
version = `0.0.1-SNAPSHOT`
sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    compile(`org.springframework.boot:spring-boot-starter-web`)
    testCompile(`org.springframework.boot:spring-boot-starter-test`)
}
複製程式碼

配置服務類

配置一個用於非同步任務排程的 Mock 服務。

@Service
public class WebAsyncService {
    public String generateUUID() {
        return UUID.randomUUID().toString();
    }
}
複製程式碼

配置非同步處理控制器並注入以上服務 Bean。

@RestController
public class WebAsyncController {
    private final WebAsyncService asyncService;
    private final static String ERROR_MESSAGE = "Task error";
    private final static String TIME_MESSAGE = "Task timeout";

    @Autowired
    public WebAsyncController(WebAsyncService asyncService) {
        this.asyncService = asyncService;
    }
}
複製程式碼

3. 正常非同步任務

配置一個正常的 WebAsyncTask 任務物件，設定任務 超時時間 為 10s。非同步任務執行採用 Thread.sleep(long) 模擬，這裡設定 非同步執行緒 睡眠時間為 5s。

@GetMapping("/completion")
public WebAsyncTask<String> asyncTaskCompletion() {
    // 列印處理執行緒名
    out.println(format("請求處理執行緒：%s", currentThread().getName()));

    // 模擬開啟一個非同步任務，超時時間為10s
    WebAsyncTask<String> asyncTask = new WebAsyncTask<>(10 * 1000L, () -> {
        out.println(format("非同步工作執行緒：%s", currentThread().getName()));
        // 任務處理時間5s，不超時
        sleep(5 * 1000L);
        return asyncService.generateUUID();
    });

    // 任務執行完成時呼叫該方法
    asyncTask.onCompletion(() -> out.println("任務執行完成"));
    out.println("繼續處理其他事情");
    return asyncTask;
}
複製程式碼

啟動 Spring Boot 專案，訪問 http://localhost:8080/completion ，發起 正常 的非同步任務請求。

觀察控制檯輸出，可以驗證 WebAsyncTask 的非同步處理流程正常。

請求處理執行緒：http-nio-8080-exec-2
繼續處理其他事情
非同步工作執行緒：MvcAsync1
任務執行完成
複製程式碼

Web 頁面正常響應，頁面響應訊息如下：

實戰Spring Boot 2.0系列(四) – 使用WebAsyncTask處理非同步任務

注意：WebAsyncTask.onCompletion(Runnable) ：在當前任務執行結束以後，無論是執行成功還是異常中止，onCompletion的回撥最終都會被呼叫。

4. 丟擲異常非同步任務

配置一個 錯誤 的 WebAsyncTask 任務物件，設定任務 超時時間 為 10s。在非同步任務執行方法中 丟擲異常。

@GetMapping("/exception")
public WebAsyncTask<String> asyncTaskException() {
    // 列印處理執行緒名
    out.println(format("請求處理執行緒：%s", currentThread().getName()));

    // 模擬開啟一個非同步任務，超時時間為10s
    WebAsyncTask<String> asyncTask = new WebAsyncTask<>(10 * 1000L, () -> {
        out.println(format("非同步工作執行緒：%s", currentThread().getName()));
        // 任務處理時間5s，不超時
        sleep(5 * 1000L);
        throw new Exception(ERROR_MESSAGE);
    });

    // 任務執行完成時呼叫該方法
    asyncTask.onCompletion(() -> out.println("任務執行完成"));
    asyncTask.onError(() -> {
        out.println("任務執行異常");
        return ERROR_MESSAGE;
    });

    out.println("繼續處理其他事情");
    return asyncTask;
}
複製程式碼

啟動 Spring Boot 專案，訪問 http://localhost:8080/exception ，發起 異常 的非同步任務請求。

Web 頁面響應異常資訊如下：

實戰Spring Boot 2.0系列(四) – 使用WebAsyncTask處理非同步任務

觀察控制檯輸出，可以驗證 WebAsyncTask 對於 異常請求 的非同步處理過程。

請求處理執行緒：http-nio-8080-exec-1
繼續處理其他事情
非同步工作執行緒：MvcAsync2
2018-06-18 21:12:10.110 ERROR 89875 --- [nio-8080-exec-2] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] threw exception

java.lang.Exception: Task error
	at io.ostenant.springboot.sample.controller.WebAsyncController.lambda$asyncTaskException$2(WebAsyncController.java:55) ~[classes/:na]
	at org.springframework.web.context.request.async.WebAsyncManager.lambda$startCallableProcessing$4(WebAsyncManager.java:317) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) ~[na:1.8.0_172]
	at java.util.concurrent.FutureTask.run(FutureTask.java:266) ~[na:1.8.0_172]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_172]

2018-06-18 21:12:10.111 ERROR 89875 --- [nio-8080-exec-2] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.Exception: Task error] with root cause

java.lang.Exception: Task error
	at io.ostenant.springboot.sample.controller.WebAsyncController.lambda$asyncTaskException$2(WebAsyncController.java:55) ~[classes/:na]
	at org.springframework.web.context.request.async.WebAsyncManager.lambda$startCallableProcessing$4(WebAsyncManager.java:317) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) ~[na:1.8.0_172]
	at java.util.concurrent.FutureTask.run(FutureTask.java:266) ~[na:1.8.0_172]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_172]

任務執行異常
2018-06-18 21:12:10.144  WARN 89875 --- [nio-8080-exec-2] o.apache.catalina.core.AsyncContextImpl  : onError() failed for listener of type [org.apache.catalina.core.AsyncListenerWrapper]

java.lang.IllegalArgumentException: Cannot dispatch without an AsyncContext
	at org.springframework.util.Assert.notNull(Assert.java:193) ~[spring-core-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at org.springframework.web.context.request.async.StandardServletAsyncWebRequest.dispatch(StandardServletAsyncWebRequest.java:131) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at org.springframework.web.context.request.async.WebAsyncManager.setConcurrentResultAndDispatch(WebAsyncManager.java:353) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at org.springframework.web.context.request.async.WebAsyncManager.lambda$startCallableProcessing$2(WebAsyncManager.java:304) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at org.springframework.web.context.request.async.StandardServletAsyncWebRequest.lambda$onError$0(StandardServletAsyncWebRequest.java:146) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at java.util.ArrayList.forEach(ArrayList.java:1257) ~[na:1.8.0_172]
	at org.springframework.web.context.request.async.StandardServletAsyncWebRequest.onError(StandardServletAsyncWebRequest.java:146) ~[spring-web-5.0.7.RELEASE.jar:5.0.7.RELEASE]
	at org.apache.catalina.core.AsyncListenerWrapper.fireOnError(AsyncListenerWrapper.java:49) ~[tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.catalina.core.AsyncContextImpl.setErrorState(AsyncContextImpl.java:397) ~[tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.catalina.connector.CoyoteAdapter.asyncDispatch(CoyoteAdapter.java:239) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.coyote.AbstractProcessor.dispatch(AbstractProcessor.java:232) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:53) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:790) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1468) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) [na:1.8.0_172]
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [na:1.8.0_172]
	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) [tomcat-embed-core-8.5.31.jar:8.5.31]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_172]

任務執行完成
複製程式碼

注意：WebAsyncTask.onError(Callable<?>) ：當非同步任務丟擲異常的時候，onError()方法即會被呼叫。

5. 超時非同步任務

配置一個正常的 WebAsyncTask 任務物件，設定任務 超時時間 為 10s。非同步任務執行採用 Thread.sleep(long) 模擬，這裡設定 非同步執行緒 睡眠時間為 15s，引發非同步任務超時。

@GetMapping("/timeout")
public WebAsyncTask<String> asyncTaskTimeout() {
    // 列印處理執行緒名
    out.println(format("請求處理執行緒：%s", currentThread().getName()));

    // 模擬開啟一個非同步任務，超時時間為10s
    WebAsyncTask<String> asyncTask = new WebAsyncTask<>(10 * 1000L, () -> {
        out.println(format("非同步工作執行緒：%s", currentThread().getName()));
        // 任務處理時間5s，不超時
        sleep(15 * 1000L);
        return TIME_MESSAGE;
    });

    // 任務執行完成時呼叫該方法
    asyncTask.onCompletion(() -> out.println("任務執行完成"));
    asyncTask.onTimeout(() -> {
        out.println("任務執行超時");
        return TIME_MESSAGE;
    });

    out.println("繼續處理其他事情");
    return asyncTask;
}
複製程式碼

啟動 Spring Boot 專案，訪問 http://localhost:8080/timeout ，發起 超時 的非同步任務請求。

觀察控制檯輸出，可以驗證 WebAsyncTask 的非同步超時處理的過程。

請求處理執行緒：http-nio-8080-exec-1
繼續處理其他事情
非同步工作執行緒：MvcAsync3
任務執行超時
任務執行完成
複製程式碼

Web 頁面常響應超時提示資訊，頁面響應訊息如下：

實戰Spring Boot 2.0系列(四) – 使用WebAsyncTask處理非同步任務

注意：WebAsyncTask.onTimeout(Callable<?>) ：當非同步任務發生超時的時候，onTimeout()方法即會被呼叫。

6. 執行緒池非同步任務

上面的三種情況中的 非同步任務 預設不是採用 執行緒池機制 進行管理的。

也就是說，一個請求進來，雖然釋放了處理執行緒，但是系統依舊會為每個請求建立一個 非同步任務執行緒，也就是上面看到的 MvcAsync 開頭的 非同步任務執行緒。

後果就是開銷嚴重，所以通常採用 執行緒池 進行統一的管理，直接在 WebAsyncTask 類構造器傳入一個 ThreadPoolTaskExecutor 物件例項即可。

構造一個執行緒池 Bean 物件：

@Configuration
public class TaskConfiguration {
    @Bean("taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(5);
        taskExecutor.setMaxPoolSize(10);
        taskExecutor.setQueueCapacity(10);
        taskExecutor.setThreadNamePrefix("asyncTask");
        return taskExecutor;
    }
}
複製程式碼

在控制器中注入 ThreadPoolTaskExecutor 物件，重新配置基於 執行緒池 的 非同步任務處理。

@Autowired
@Qualifier("taskExecutor")
private ThreadPoolTaskExecutor executor;

@GetMapping("/threadPool")
public WebAsyncTask<String> asyncTaskThreadPool() {
    return new WebAsyncTask<>(10 * 1000L, executor,
            () -> {
                out.println(format("非同步工作執行緒：%s", currentThread().getName()));
                return asyncService.generateUUID();
            });
}
複製程式碼

併發地請求 http://localhost:8080/threadPool ，觀察控制檯輸出的 非同步執行緒 資訊，可以發現 非同步任務 直接從 執行緒池 中獲取 非同步執行緒。

非同步工作執行緒：asyncTask1
非同步工作執行緒：asyncTask2
非同步工作執行緒：asyncTask3
非同步工作執行緒：asyncTask4
非同步工作執行緒：asyncTask5
非同步工作執行緒：asyncTask1
非同步工作執行緒：asyncTask2
非同步工作執行緒：asyncTask3
非同步工作執行緒：asyncTask4
非同步工作執行緒：asyncTask5
複製程式碼

小結

本文介紹了 Spring Boot 提供的 WebAsyncTask 的非同步程式設計 API。相比上問介紹的 @Async 註解，WebAsyncTask 提供更加健全的 超時處理 和 異常處理 支援。

歡迎關注技術公眾號： 零壹技術棧

零壹技術棧

本帳號將持續分享後端技術乾貨，包括虛擬機器基礎，多執行緒程式設計，高效能框架，非同步、快取和訊息中介軟體，分散式和微服務，架構學習和進階等學習資料和文章。

相關文章