SpringBoot中使用@Async实现异步调用
什么是异步调用?异步调用对应的是同步调用，同步调用指程序按照定义顺序依次执行，每一行程序都必须等待上
一行程序执行完成之后才能执行；异步调用指程序在顺序执行时，不等待异步调用的语句返回结果就执行后面的程
序。
1、pom依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.6</version>
<relativePath/>
</parent>
<groupId>com.async</groupId>
<artifactId>spring-boot-async</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-async</name>
<description>Spring Boot 中使用@Async实现异步调用，加速任务执行！</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
2、同步调用
下面通过一个简单示例来直观的理解什么是同步调用。
定义 Task 类，创建三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10秒内）。
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Random;
/**
* @author zhangshixing
* @date 2021年10月29日 14:41
*/
@Slf4j
@Component
public class AsyncTasks {
public static Random random = new Random();
public void doTaskOne() throws Exception {
log.info("开始做任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务一，耗时：" + (end - start) + "毫秒");
}
public void doTaskTwo() throws Exception {
log.info("开始做任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务二，耗时：" + (end - start) + "毫秒");
}
public void doTaskThree() throws Exception {
log.info("开始做任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务三，耗时：" + (end - start) + "毫秒");
}
}
在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.CompletableFuture;
@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {
@Autowired
private AsyncTasks asyncTasks;
@Test
public void test() throws Exception {
asyncTasks.doTaskOne();
asyncTasks.doTaskTwo();
asyncTasks.doTaskThree();
}
}
执行单元测试，可以看到类似如下输出：
开始做任务一
完成任务一，耗时：8577毫秒
开始做任务二
完成任务二，耗时：185毫秒
开始做任务三
完成任务三，耗时：3702毫秒
任务一、任务二、任务三顺序的执行完了，换言之doTaskOne、doTaskTwo、doTaskThree三个函数顺序的执行
完成。
3、异步调用
上述的同步调用虽然顺利的执行完了三个任务，但是可以看到执行时间比较长，若这三个任务本身之间不存在依赖
关系，可以并发执行的话，同步调用在执行效率方面就比较差，可以考虑通过异步调用的方式来并发执行。
在Spring Boot中，我们只需要通过使用@Async注解就能简单的将原来的同步函数变为异步函数，Task类改在为
如下模式：
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.Random;
/**
* @author zhangshixing
* @date 2021年10月29日 15:28
*/
@Slf4j
@Component
public class AsyncTasks1 {
public static Random random = new Random();
@Async
public void doTaskOne() throws Exception {
log.info("开始做任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务一，耗时：" + (end - start) + "毫秒");
}
@Async
public void doTaskTwo() throws Exception {
log.info("开始做任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务二，耗时：" + (end - start) + "毫秒");
}
@Async
public void doTaskThree() throws Exception {
log.info("开始做任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务三，耗时：" + (end - start) + "毫秒");
}
}
为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync，如下所示：
package com.async;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@EnableAsync
@SpringBootApplication
public class SpringBootAsyncApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootAsyncApplication.class, args);
}
}
在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.CompletableFuture;
@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {
@Autowired
private AsyncTasks1 asyncTasks1;
@Test
public void test1() throws Exception {
asyncTasks1.doTaskOne();
asyncTasks1.doTaskTwo();
asyncTasks1.doTaskThree();
}
}
执行单元测试，可以看到类似如下输出：
开始做任务二
开始做任务一
此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：
-
没有任何任务相关的输出
-
有部分任务相关的输出
-
乱序的任务相关的输出
原因是目前doTaskOne、doTaskTwo、doTaskThree三个函数的时候已经是异步执行了。主程序在异步调用
之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束
了，导致了不完整或是没有输出任务相关内容的情况。
注：@Async所修饰的函数不要定义为static类型，这样异步调用不会生效。
为了让doTaskOne、doTaskTwo、doTaskThree能正常结束，假设我们需要统计一下三个任务并发执行共耗时多
少，这就需要等到上述三个函数都完成调动之后记录时间，并计算结果。那么我们如何判断上述三个异步调用是否
已经执行完成呢？我们需要使用CompletableFuture<T>来返回异步调用的结果：
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
/**
* @author zhangshixing
* @date 2021年10月29日 15:47
*/
@Slf4j
@Component
public class AsyncTasks2 {
public static Random random = new Random();
@Async
public CompletableFuture<String> doTaskOne() throws Exception {
log.info("开始做任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务一，耗时：" + (end - start) + "毫秒");
return CompletableFuture.completedFuture("任务一完成");
}
@Async
public CompletableFuture<String> doTaskTwo() throws Exception {
log.info("开始做任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务二，耗时：" + (end - start) + "毫秒");
return CompletableFuture.completedFuture("任务二完成");
}
@Async
public CompletableFuture<String> doTaskThree() throws Exception {
log.info("开始做任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务三，耗时：" + (end - start) + "毫秒");
return CompletableFuture.completedFuture("任务三完成");
}
}
按照如上方式改造一下其他两个异步函数之后，下面我们改造一下测试用例，让测试在等待完成三个异步调用之后
来做一些其他事情。
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.CompletableFuture;
@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {
@Autowired
private AsyncTasks2 asyncTasks2;
@Test
public void test2() throws Exception {
long start = System.currentTimeMillis();
CompletableFuture<String> task1 = asyncTasks2.doTaskOne();
CompletableFuture<String> task2 = asyncTasks2.doTaskTwo();
CompletableFuture<String> task3 = asyncTasks2.doTaskThree();
CompletableFuture.allOf(task1, task2, task3).join();
long end = System.currentTimeMillis();
log.info("任务全部完成，总耗时：" + (end - start) + "毫秒");
}
}
看看我们做了哪些改变：
- 在测试用例一开始记录开始时间
- 在调用三个异步函数的时候，返回
CompletableFuture<String>类型的结果对象 - 通过
CompletableFuture.allOf(task1, task2, task3).join()实现三个异步任务都结束之前的阻塞效果 - 三个任务都完成之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。
执行一下上述的单元测试，可以看到如下结果：
开始做任务二
开始做任务一
完成任务二，耗时：5375毫秒
开始做任务三
完成任务一，耗时：6298毫秒
完成任务三，耗时：9388毫秒
任务全部完成，总耗时：14780毫秒
可以看到，通过异步调用，让任务一、二、三并发执行，有效的减少了程序的总运行时间。
4、千万不要这样使用@Async注解
在实际的项目中，对于一些用时比较长的代码片段或者函数，我们可以采用异步的方式来执行，这样就不会影响整
体的流程了。比如我在一个用户请求中需要上传一些文件，但是上传文件的耗时会相对来说比较长，这个时候如果
上传文件的成功与否不影响主流程的话，就可以把上传文件的操作异步化，在spring boot中比较常见的方式就是
把要异步执行的代码片段封装成一个函数，然后在函数头使用@Async注解，就可以实现代码的异步执行（当然首
先得在启动类上加上@EnableAsync注解了）。
下面这里主要讲解使用 @Async 注解中遇到的一个坑。
那么这个坑是什么呢?就是如果你在同一个类里面调用一个自己的被@Async修饰的函数时，这个函数将不会被异
步执行，它依然是同步执行的，下面来演示一下。
记得在启动类上加上@EnableAsync注解。
package com.async;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@EnableAsync
@SpringBootApplication
public class SpringBootAsyncApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootAsyncApplication.class, args);
}
}
然后再新建一个类Task，用来放三个异步任务doTaskOne、doTaskTwo、doTaskThree：
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.Random;
/**
* @author zhangshixing
* @date 2021年10月29日 15:28
*/
@Slf4j
@Component
public class AsyncTasks1 {
public static Random random = new Random();
@Async
public void doTaskOne() throws Exception {
log.info("开始做任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务一，耗时：" + (end - start) + "毫秒");
}
@Async
public void doTaskTwo() throws Exception {
log.info("开始做任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务二，耗时：" + (end - start) + "毫秒");
}
@Async
public void doTaskThree() throws Exception {
log.info("开始做任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务三，耗时：" + (end - start) + "毫秒");
}
}
在单元测试类上注入Task，在测试用例上测试这三个方法的执行过程：
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests1 {
@Autowired
AsyncTasks1 asyncTasks1;
@Test
void contextLoads() throws Exception {
asyncTasks1.doTaskOne();
asyncTasks1.doTaskTwo();
asyncTasks1.doTaskThree();
Thread.sleep(10000);
}
}
为了让这三个方法执行完，我们需要再单元测试用例上的最后一行加上一个延时，不然等函数退出了，异步任务还
没执行完。
我们启动看看效果：
开始做任务一
开始做任务二
完成任务二，耗时：314毫秒
开始做任务三
完成任务一，耗时：1365毫秒
完成任务三，耗时：3376毫秒
我们看到三个任务确实是异步执行的，那我们再看看错误的使用方法。
我们在测试类里面把这三个函数再写一遍，并在测试用例上调用测试类自己的方法：
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.annotation.Async;
import java.util.Random;
@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests2 {
public static Random random = new Random();
@Test
void contextLoads() throws Exception {
doTaskOne();
doTaskTwo();
doTaskThree();
Thread.sleep(10000);
}
@Async
public void doTaskOne() throws Exception {
System.out.println("开始做任务一");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
}
@Async
public void doTaskTwo() throws Exception {
System.out.println("开始做任务二");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
}
@Async
public void doTaskThree() throws Exception {
System.out.println("开始做任务三");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
}
}
我们再看看效果：
开始做任务一
完成任务一，耗时：1332毫秒
开始做任务二
完成任务二，耗时：7568毫秒
开始做任务三
完成任务三，耗时：1419毫秒
它们竟然是顺序执行的！也就是同步执行，并没有达到异步的效果。
5、用@Async会内存溢出?看看你的线程池配置了没?
上面我们介绍了如何使用@Async注解来创建异步任务，我可以用这种方法来实现一些并发操作，以加速任务的执
行效率。但是，如果只是如前文那样直接简单的创建来使用，可能还是会碰到一些问题。存在有什么问题呢?先来
思考下，下面的这个接口，通过异步任务加速执行的实现，是否存在问题或风险呢?
package com.async.controller;
import com.async.AsyncTasks2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;
/**
* @author zhangshixing
* @date 2021年10月30日 9:15
*/
@RestController
public class HelloController {
@Autowired
private AsyncTasks2 asyncTasks;
@GetMapping("/hello")
public String hello() throws Exception {
// 将可以并行的处理逻辑，拆分成三个异步任务同时执行
CompletableFuture<String> task1 = asyncTasks.doTaskOne();
CompletableFuture<String> task2 = asyncTasks.doTaskTwo();
CompletableFuture<String> task3 = asyncTasks.doTaskThree();
CompletableFuture.allOf(task1, task2, task3).join();
return "Hello World";
}
}
虽然，从单次接口调用来说，是没有问题的。但当接口被客户端频繁调用的时候，异步任务的数量就会大量增长：
3 x n（n为请求数量），如果任务处理不够快，就很可能会出现内存溢出的情况。那么为什么会内存溢出呢？根本
原因是由于Spring Boot默认用于异步任务的线程池是这样配置的：
图中我标出的两个重要参数是需要关注的：
-
queueCapacity：缓冲队列的容量，默认为INT的最大值（2的31次方-1）。 -
maxSize：允许的最大线程数，默认为INT的最大值（2的31次方-1）。
所以，默认情况下，一般任务队列就可能把内存给堆满了。所以，我们真正使用的时候，还需要对异步任务的执行
线程池做一些基础配置，以防止出现内存溢出导致服务不可用的问题。
5.1 配置默认线程池
默认线程池的配置很简单，只需要在配置文件中完成即可，主要有以下这些参数：
spring.task.execution.pool.core-size=2
spring.task.execution.pool.max-size=5
spring.task.execution.pool.queue-capacity=10
spring.task.execution.pool.keep-alive=60s
spring.task.execution.pool.allow-core-thread-timeout=true
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
spring.task.execution.thread-name-prefix=task-
具体配置含义如下：
-
spring.task.execution.pool.core-size：线程池创建时的初始化线程数，默认为8 -
spring.task.execution.pool.max-size：线程池的最大线程数，默认为int最大值 -
spring.task.execution.pool.queue-capacity：用来缓冲执行任务的队列，默认为int最大值 -
spring.task.execution.pool.keep-alive：线程终止前允许保持空闲的时间 -
spring.task.execution.pool.allow-core-thread-timeout：是否允许核心线程超时 -
spring.task.execution.shutdown.await-termination：是否等待剩余任务完成后才关闭应用 -
spring.task.execution.shutdown.await-termination-period：等待剩余任务完成的最大时间 -
spring.task.execution.thread-name-prefix：线程名的前缀，设置好了之后可以方便我们在日志中查看处理任务所在的线程池
5.2 动手试一试
首先，在没有进行线程池配置之前，可以先执行一下单元测试：
package com.async;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.CompletableFuture;
@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {
@Autowired
private AsyncTasks2 asyncTasks2;
@Test
public void test2() throws Exception {
long start = System.currentTimeMillis();
CompletableFuture<String> task1 = asyncTasks2.doTaskOne();
CompletableFuture<String> task2 = asyncTasks2.doTaskTwo();
CompletableFuture<String> task3 = asyncTasks2.doTaskThree();
CompletableFuture.allOf(task1, task2, task3).join();
long end = System.currentTimeMillis();
log.info("任务全部完成，总耗时：" + (end - start) + "毫秒");
}
}
由于默认线程池的核心线程数是8，所以3个任务会同时开始执行，日志输出是这样的：
开始做任务一
开始做任务二
开始做任务三
完成任务二，耗时：770毫秒
完成任务一，耗时：7859毫秒
完成任务三，耗时：9598毫秒
任务全部完成，总耗时：9611毫秒
接着，可以尝试在配置文件中增加如下的线程池配置
spring.task.execution.pool.core-size=2
spring.task.execution.pool.max-size=5
spring.task.execution.pool.queue-capacity=10
spring.task.execution.pool.keep-alive=60s
spring.task.execution.pool.allow-core-thread-timeout=true
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
spring.task.execution.thread-name-prefix=task-
日志输出的顺序会变成如下的顺序：
开始做任务二
开始做任务一
完成任务二，耗时：185毫秒
开始做任务三
完成任务一，耗时：2762毫秒
完成任务三，耗时：4307毫秒
任务全部完成，总耗时：4510毫秒
- 任务一和任务二会马上占用核心线程，任务三进入队列等待。
- 任务二完成，释放出一个核心线程，任务三从队列中移出，并占用核心线程开始处理。
