SpringBoot中使用@Async实现异步调用

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毫秒

• 任务一和任务二会马上占用核心线程，任务三进入队列等待。
• 任务二完成，释放出一个核心线程，任务三从队列中移出，并占用核心线程开始处理。