第一文搞懂SpringBoot如何利用@Async實現異步調用目錄前言簡單使用異步處理異步回調自定義線程池注意事項（一定注意）

前言

異步調用幾乎是處理高并發，解決性能問題常用的手段，如何開啟異步調用？SpringBoot中提供了非常簡單的方式，就是一個注解@Async。今天我們重新認識一下@Async,以及注意事項

簡單使用

新建三個作業任務：

@Service

publicclassTaskDemo{

privatestaticLoggerlogger=LoggerFactory.getLogger(TaskDemo.class);

publicvoidexecute1(){

("處理耗時任務1......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務1......結束");

publicvoidexecute2(){

("處理耗時任務2......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務2......結束");

publicvoidexecute3(){

("處理耗時任務3......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務3......結束");

}

測試代碼：

@RestController

publicclassTaskController{

@Autowired

privateTaskDemotaskDemo;

@GetMapping("/task/test")

publicStringtestTask(){

taskDemo.execute1();

taskDemo.execute2();

taskDemo.execute3();

return"ok";

}

執行后我們可以發現，上面的代碼是同一個線程的同步執行，整體耗時9秒才完成。

異步處理

springboot的異步，是非常簡單的，加2個注解即可

@Service

publicclassTaskDemo{

privatestaticLoggerlogger=LoggerFactory.getLogger(TaskDemo.class);

@Async

publicvoidexecute1(){

("處理耗時任務1......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務1......結束");

@Async

publicvoidexecute2(){

("處理耗時任務2......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務2......結束");

@Async

publicvoidexecute3(){

("處理耗時任務3......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務3......結束");

}

@SpringBootApplication

@EnableAsync

publicclassDemoApp{

publicstaticvoidmain(String[]args){

SpringApplication.run(DemoApp.class,args);

}

增加了@Async和@EnableAsync兩個注解

從執行結果發現，整個流程用了3秒，以及用了3個線程執行。完成了異步調用

異步回調

有些場景我們需要知道異步處理的任務什么時候完成，需要做額外的業務處理。如：我們需要在3個任務都完成后，提示一下給用戶

@Service

publicclassTaskDemo{

privatestaticLoggerlogger=LoggerFactory.getLogger(TaskDemo.class);

@Async

publicFutureStringexecute1(){

("處理耗時任務1......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務1......結束");

returnnewAsyncResult("任務1ok");

@Async

publicFutureStringexecute2(){

("處理耗時任務2......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務2......結束");

returnnewAsyncResult("任務2ok");

@Async

publicFutureStringexecute3(){

("處理耗時任務3......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務3......結束");

returnnewAsyncResult("任務3ok");

}

@RestController

publicclassTaskController{

privatestaticLoggerlogger=LoggerFactory.getLogger(TaskController.class);

@Autowired

privateTaskDemotaskDemo;

@GetMapping("/task/test")

publicStringtestTask()throwsInterruptedException{

FutureStringtask1=taskDemo.execute1();

FutureStringtask2=taskDemo.execute2();

FutureStringtask3=taskDemo.execute3();

while(true){

if(task1.isDone()task2.isDone()task3.isDone()){

break;

TimeUnit.SECONDS.sleep(1);

("3個任務都處理完成");

return"ok";

}

執行結果發現，在請求線程里面給用戶提示了3個任務都處理完成了。

這段代碼主要改變了什么：

1、把具體任務返回類型改為了Future類型對象

2、在調用任務時，循環判斷任務是否處理完

自定義線程池

說到異步處理，一定要考慮到線程池，什么是線程池，小伙伴可自行網補。@Async的線程池定義比較方便，直接上代碼：

@Configuration

publicclassThreadPoolConfig{

@Bean(name="taskPool01Executor")

publicThreadPoolTaskExecutorgetTaskPool01Executor(){

ThreadPoolTaskExecutortaskExecutor=newThreadPoolTaskExecutor();

//核心線程數

taskExecutor.setCorePoolSize(10);

//線程池維護線程的最大數量,只有在緩沖隊列滿了之后才會申請超過核心線程數的線程

taskExecutor.setMaxPoolSize(100);

//緩存隊列

taskExecutor.setQueueCapacity(50);

//許的空閑時間,當超過了核心線程出之外的線程在空閑時間到達之后會被銷毀

taskExecutor.setKeepAliveSeconds(200);

//異步方法內部線程名稱

taskExecutor.setThreadNamePrefix("TaskPool-01-");

*當線程池的任務緩存隊列已滿并且線程池中的線程數目達到maximumPoolSize，如果還有任務到來就會采取任務拒絕策略

*通常有以下四種策略：

*ThreadPoolExecutor.AbortPolicy:丟棄任務并拋出RejectedExecutionException異常。

*ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不拋出異常。

*ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，然后重新嘗試執行任務（重復此過程）

*ThreadPoolExecutor.CallerRunsPolicy：重試添加當前的任務，自動重復調用execute()方法，直到成功

taskExecutor.setRejectedExecutionHandler(newThreadPoolExecutor.AbortPolicy());

taskExecutor.setWaitForTasksToCompleteOnShutdown(true);

taskExecutor.initialize();

returntaskExecutor;

@Bean(name="taskPool02Executor")

publicThreadPoolTaskExecutorgetTaskPool02Executor(){

ThreadPoolTaskExecutortaskExecutor=newThreadPoolTaskExecutor();

//核心線程數

taskExecutor.setCorePoolSize(10);

//線程池維護線程的最大數量,只有在緩沖隊列滿了之后才會申請超過核心線程數的線程

taskExecutor.setMaxPoolSize(100);

//緩存隊列

taskExecutor.setQueueCapacity(50);

//許的空閑時間,當超過了核心線程出之外的線程在空閑時間到達之后會被銷毀

taskExecutor.setKeepAliveSeconds(200);

//異步方法內部線程名稱

taskExecutor.setThreadNamePrefix("TaskPool-02-");

*當線程池的任務緩存隊列已滿并且線程池中的線程數目達到maximumPoolSize，如果還有任務到來就會采取任務拒絕策略

*通常有以下四種策略：

*ThreadPoolExecutor.AbortPolicy:丟棄任務并拋出RejectedExecutionException異常。

*ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不拋出異常。

*ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務，然后重新嘗試執行任務（重復此過程）

*ThreadPoolExecutor.CallerRunsPolicy：重試添加當前的任務，自動重復調用execute()方法，直到成功

taskExecutor.setRejectedExecutionHandler(newThreadPoolExecutor.AbortPolicy());

taskExecutor.setWaitForTasksToCompleteOnShutdown(true);

taskExecutor.initialize();

returntaskExecutor;

}

定義了2個線程池Bean

@Service

publicclassTaskDemo{

privatestaticLoggerlogger=LoggerFactory.getLogger(TaskDemo.class);

@Async("taskPool01Executor")

publicFutureStringexecute1(){

("處理耗時任務1......開始");

try{

TimeUnit.SECONDS.sleep(3);

}catch(InterruptedExceptione){

e.printStackTrace();

("處理耗時任務1......結束");

returnnewAsyncResult("任務1ok");

@Async("taskPool01Executor")

publicFutureStringexecute2(){

("處理耗時任務2......開始");

try{

TimeUnit.SECONDS.sleep(3);