关于java:Spring-Boot中使用Async实现异步调用加速任务的执行

13次阅读

共计 5095 个字符，预计需要花费 13 分钟才能阅读完成。

什么是“异步调用”？“异步调用”对应的是“同步调用”，同步调用指程序依照定义程序顺次执行，每一行程序都必须期待上一行程序执行实现之后能力执行；异步调用指程序在程序执行时，不期待异步调用的语句返回后果就执行前面的程序。

上面通过一个简略示例来直观的了解什么是同步调用：

定义 Task 类，创立三个处理函数别离模仿三个执行工作的操作，操作耗费工夫随机取（10 秒内）

@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 三个函数。

@Slf4j
@SpringBootTest
public class Chapter75ApplicationTests {

    @Autowired
    private AsyncTasks asyncTasks;

    @Test
    public void test() throws Exception {asyncTasks.doTaskOne();
        asyncTasks.doTaskTwo();
        asyncTasks.doTaskThree();}

}

执行单元测试，能够看到相似如下输入：

2021-09-11 23:19:12.922  INFO 92539 --- [main] com.didispace.chapter75.AsyncTasks       : 开始做工作一
2021-09-11 23:19:17.788  INFO 92539 --- [main] com.didispace.chapter75.AsyncTasks       : 实现工作一，耗时：4865 毫秒
2021-09-11 23:19:17.788  INFO 92539 --- [main] com.didispace.chapter75.AsyncTasks       : 开始做工作二
2021-09-11 23:19:24.851  INFO 92539 --- [main] com.didispace.chapter75.AsyncTasks       : 实现工作二，耗时：7063 毫秒
2021-09-11 23:19:24.851  INFO 92539 --- [main] com.didispace.chapter75.AsyncTasks       : 开始做工作三
2021-09-11 23:19:26.928  INFO 92539 --- [main] com.didispace.chapter75.AsyncTasks       : 实现工作三，耗时：2076 毫秒

工作一、工作二、工作三程序的执行完了，换言之 doTaskOne、doTaskTwo、doTaskThree 三个函数程序的执行实现。

上述的同步调用尽管顺利的执行完了三个工作，然而能够看到执行工夫比拟长，若这三个工作自身之间不存在依赖关系，能够并发执行的话，同步调用在执行效率方面就比拟差，能够思考通过异步调用的形式来并发执行。

在 Spring Boot 中，咱们只须要通过应用 @Async 注解就能简略的将原来的同步函数变为异步函数，Task 类改在为如下模式：

@Slf4j
@Component
public class AsyncTasks {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，如下所示：

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

}

此时能够重复执行单元测试，您可能会遇到各种不同的后果，比方：

没有任何工作相干的输入
有局部工作相干的输入
乱序的工作相干的输入
起因是目前 doTaskOne、doTaskTwo、doTaskThree 三个函数的时候曾经是异步执行了。主程序在异步调用之后，主程序并不会理睬这三个函数是否执行实现了，因为没有其余须要执行的内容，所以程序就主动完结了，导致了不残缺或是没有输入工作相干内容的状况。

注：@Async所润饰的函数不要定义为 static 类型，这样异步调用不会失效

为了让 doTaskOne、doTaskTwo、doTaskThree 能失常完结，假如咱们须要统计一下三个工作并发执行共耗时多少，这就须要等到上述三个函数都实现调动之后记录时间，并计算结果。

那么咱们如何判断上述三个异步调用是否曾经执行实现呢？咱们须要应用 CompletableFuture<T> 来返回异步调用的后果，就像如下形式革新 doTaskOne 函数：

    @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("工作一实现");
}

依照如上形式革新一下其余两个异步函数之后，上面咱们革新一下测试用例，让测试在期待实现三个异步调用之后来做一些其余事件。

@Test
public void test() throws Exception {long start = System.currentTimeMillis();

    CompletableFuture<String> task1 = asyncTasks.doTaskOne();
    CompletableFuture<String> task2 = asyncTasks.doTaskTwo();
    CompletableFuture<String> task3 = asyncTasks.doTaskThree();

    CompletableFuture.allOf(task1, task2, task3).join();

    long end = System.currentTimeMillis();

    log.info("工作全副实现，总耗时：" + (end - start) + "毫秒");
}

看看咱们做了哪些扭转：

在测试用例一开始记录开始工夫
在调用三个异步函数的时候，返回 CompletableFuture<String> 类型的后果对象
通过 CompletableFuture.allOf(task1, task2, task3).join() 实现三个异步工作都完结之前的阻塞成果
三个工作都实现之后，依据完结工夫 – 开始工夫，计算出三个工作并发执行的总耗时。

执行一下上述的单元测试，能够看到如下后果：

2021-09-11 23:33:38.842  INFO 95891 --- [task-3] com.didispace.chapter75.AsyncTasks       : 开始做工作三
2021-09-11 23:33:38.842  INFO 95891 --- [task-2] com.didispace.chapter75.AsyncTasks       : 开始做工作二
2021-09-11 23:33:38.842  INFO 95891 --- [task-1] com.didispace.chapter75.AsyncTasks       : 开始做工作一
2021-09-11 23:33:45.155  INFO 95891 --- [task-2] com.didispace.chapter75.AsyncTasks       : 实现工作二，耗时：6312 毫秒
2021-09-11 23:33:47.308  INFO 95891 --- [task-3] com.didispace.chapter75.AsyncTasks       : 实现工作三，耗时：8465 毫秒
2021-09-11 23:33:47.403  INFO 95891 --- [task-1] com.didispace.chapter75.AsyncTasks       : 实现工作一，耗时：8560 毫秒
2021-09-11 23:33:47.404  INFO 95891 --- [main] c.d.chapter75.Chapter75ApplicationTests  : 工作全副实现，总耗时：8590 毫秒

能够看到，通过异步调用，让工作一、二、三并发执行，无效的缩小了程序的总运行工夫。本系列教程《Spring Boot 2.x 基础教程》点击中转！，欢送珍藏与转发！如果学习过程中如遇艰难？能够退出咱们的 Spring 技术交换群，参加交换与探讨，更好的学习与提高！

本文的残缺工程能够查看上面仓库中 2.x 目录下的 chapter7-5 工程：