Spring Boot + @Async 实现高效的异步调用

• 同步调用：整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。
• 异步调用：只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。

1、pom.xml

在测试中引入Awaitility，所以加入相关的pom文件，具体如下：

<dependency>
    <groupId>org.awaitility</groupId>
    <artifactId>awaitility</artifactId>
    <version>4.2.0</version>
    <scope>test</scope>
</dependency>

2、启动类添加@EnableAsync

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class AsyncDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(AsyncDemoApplication.class, args);
    }
}

2、创建Task任务类

import java.util.Random;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

@Component
public class Task {

    private static Random random = new Random();

	// 同步任务
    public void syncTask(String taskNum) throws InterruptedException {
        System.out.println("开始做同步任务" + taskNum);
        long start = System.currentTimeMillis();
        TimeUnit.MILLISECONDS.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成同步任务" + taskNum + "，耗时：" + (end - start) + "毫秒");
    }

    // 异步任务
    @Async
    public Future<String> asyncTask(String taskNum) throws Exception {
        System.out.println("开始做异步任务" + taskNum);
        long start = System.currentTimeMillis();
        TimeUnit.MILLISECONDS.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成异步任务" + taskNum + "，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务" + taskNum + "完成");
    }
}

3、测试代码

import org.awaitility.Awaitility;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class AsyncDemoApplicationTests {

    @Autowired
    private Task task;

    @Test
    void syncTaskTest() throws Exception {
        long startTime = System.currentTimeMillis();
        System.out.println("====== syncTask start ======");
        task.syncTask("一");
        task.syncTask("二");
        task.syncTask("三");
        long endTime = System.currentTimeMillis();
        System.out.println("====== syncTask end ======");
        System.out.println("总任务完成耗时：" + (endTime - startTime));
    }

    @Test
    void asyncTaskTest() throws Exception {
        long startTime = System.currentTimeMillis();
        System.out.println("====== asyncTask start ======");
        Future<String> asyncTask1 = task.asyncTask("一");
        Future<String> asyncTask2 = task.asyncTask("二");
        Future<String> asyncTask3 = task.asyncTask("三");

        Awaitility.await().atMost(10, TimeUnit.SECONDS)
                .until(() -> asyncTask1.isDone() && asyncTask2.isDone() && asyncTask3.isDone());

        long endTime = System.currentTimeMillis();
        System.out.println("====== asyncTask end ======");
        System.out.println("总任务完成耗时：" + (endTime - startTime));
    }
}

4、结果验证

执行测试代码的运行结果如下：

====== syncTask start ======
开始做同步任务一
完成同步任务一，耗时：9767毫秒
开始做同步任务二
完成同步任务二，耗时：5329毫秒
开始做同步任务三
完成同步任务三，耗时：3443毫秒
====== syncTask end ======
总任务完成耗时：18558

====== asyncTask start ======
开始做异步任务一
开始做异步任务二
开始做异步任务三
完成异步任务二，耗时：102毫秒
完成异步任务一，耗时：2999毫秒
完成异步任务三，耗时：7971毫秒
====== asyncTask end ======
总任务完成耗时：8110