【SpringBoot】20 同步调用、异步调用、异步回调

Git堆栈

https://gitee.com/Lin_DH/system
介绍

同步调用：指程序在实验时，调用方需要等待函数调用返回结果后，才气继续实验下一步操作，是一种壅闭式调用。
异步调用：指程序在实验时，调用方在调用函数后立即返回，不需要等待函数调用返回结果，可以直接实验下一步操作，当函数实验完成后，会通过回调或其他方式关照调用方，得到返回结果。
回调：在调用一个函数后，需要在函数实验中或实验后，将实验结果或状态返回给调用者。
代码实现

第一步：启动类上添加 @EnableAsync 注解，开启异步功能。

1. @EnableAsync
2. @SpringBootApplication
3. public class SystemApplication extends SpringBootServletInitializer {}

复制代码

同步调用

第二步：添加同步调用业务逻辑
注：@Async 注解不能修饰的 static 修饰的函数，该类型的函数异步调用不会见效。

1. package com.lm.system.task;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.stereotype.Component;
6. import java.util.Random;
8. /**
9. * 同步调用
10. * @author DUHAOLIN
11. * @date 2024/10/17
12. */
13. @Slf4j
14. @Component
15. public class SyncTask {
17.     public static Random random = new Random();
19.     public void one() throws InterruptedException {
20.         commonTask("一");
21.     }
22.    
25.     public void two() throws InterruptedException {
26.         commonTask("二");
27.     }
29.     public void three() throws InterruptedException {
30.         commonTask("三");
31.     }
33.     public void commonTask(String s) throws InterruptedException {
34.         log.info("开始执行任务" + s);
35.         long startTime = System.currentTimeMillis();
36.         Thread.sleep(random.nextInt(10000));
37.         long endTime = System.currentTimeMillis();
38.         log.info("完成任务" + s + "，耗时：" + (endTime - startTime) + "毫秒");
39.     }
41. }

复制代码

第三步：测试类添加同步调用的测试方法
   SystemApplicationTests.java

1. @Slf4j
2. @SpringBootTest(classes = SystemApplication.class)
3. class SystemApplicationTests {
4.    
5.     @Resource
6.     private SyncTask syncTask;
8.     @Test
9.     public void syncTest() throws InterruptedException {
10.         long startTime = System.currentTimeMillis();
11.         syncTask.one();
12.         syncTask.two();
13.         syncTask.three();
14.         long endTime = System.currentTimeMillis();
15.         log.info("任务总耗时：" + (endTime - startTime) + "毫秒");
16.     }
17.    
18. }

复制代码

异步调用

第四步：添加异步调用业务逻辑
   AsyncTask.java

1. /**
2. * 异步调用
3. * @author DUHAOLIN
4. * @date 2024/10/17
5. */
6. @Slf4j
7. @Component
8. public class AsyncTask {
10.     public static Random random = new Random();
12.     @Async
13.     public void one() throws InterruptedException {
14.         commonTask("一");
15.     }
17.     @Async
18.     public void two() throws InterruptedException {
19.         commonTask("二");
20.     }
22.     @Async
23.     public void three() throws InterruptedException {
24.         commonTask("三");
25.     }
27.     public void commonTask(String s) throws InterruptedException {
28.         log.info("开始执行任务" + s);
29.         long startTime = System.currentTimeMillis();
30.         Thread.sleep(random.nextInt(10000));
31.         long endTime = System.currentTimeMillis();
32.         log.info("完成任务" + s + "，耗时：" + (endTime - startTime) + "毫秒");
33.     }
35. }

复制代码

第五步：测试类添加异步调用的测试方法
   SystemApplicationTests.java

1. @Resource
2. private AsyncTask asyncTask;
4. @Test
5. public void asyncTest() throws InterruptedException {
6.     long startTime = System.currentTimeMillis();
7.     asyncTask.one();
8.     asyncTask.two();
9.     asyncTask.three();
10.     long endTime = System.currentTimeMillis();
11.     log.info("任务总耗时：" + (endTime - startTime) + "毫秒");
12. }

复制代码

异步回调（常用）

第六步：添加异步回调业务逻辑
   AsyncCallBackTask.java

1. package com.lm.system.task;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.scheduling.annotation.Async;
5. import org.springframework.stereotype.Component;
7. import java.util.Random;
9. package com.lm.system.task;
11. import lombok.extern.slf4j.Slf4j;
12. import org.springframework.scheduling.annotation.Async;
13. import org.springframework.stereotype.Component;
15. import java.util.Random;
16. import java.util.concurrent.CompletableFuture;
18. /**
19. * 异步回调
20. * @author DUHAOLIN
21. * @date 2024/10/17
22. */
23. @Slf4j
24. @Component
25. public class AsyncCallBackTask {
27.     public static Random random = new Random();
29.     @Async
30.     public CompletableFuture<String> one() throws InterruptedException {
31.         log.info("开始执行任务一");
32.         long startTime = System.currentTimeMillis();
33.         Thread.sleep(random.nextInt(10000));
34.         long endTime = System.currentTimeMillis();
35.         log.info("完成任务一，耗时：" + (endTime - startTime) + "毫秒");
36.         return CompletableFuture.completedFuture("任务一执行完成");
37.     }
39.     @Async
40.     public CompletableFuture<String> two() throws InterruptedException {
41.         log.info("开始执行任务二");
42.         long startTime = System.currentTimeMillis();
43.         Thread.sleep(random.nextInt(10000));
44.         long endTime = System.currentTimeMillis();
45.         log.info("完成任务二，耗时：" + (endTime - startTime) + "毫秒");
46.         return CompletableFuture.completedFuture("任务二执行完成");
47.     }
49.     @Async
50.     public CompletableFuture<String> three() throws InterruptedException {
51.         log.info("开始执行任务三");
52.         long startTime = System.currentTimeMillis();
53.         Thread.sleep(random.nextInt(10000));
54.         long endTime = System.currentTimeMillis();
55.         log.info("完成任务三，耗时：" + (endTime - startTime) + "毫秒");
56.         return CompletableFuture.completedFuture("任务三执行完成");
57.     }
59. }

复制代码

第七步：测试类添加异步回调的测试方法
   SystemApplicationTests.java

1. @Resource
2.     private AsyncCallBackTask asyncCallBackTask;
4.     @Test
5.     public void asyncCallBackTaskTest() throws InterruptedException {
6.         long startTime = System.currentTimeMillis();
7.         CompletableFuture<String> one = asyncCallBackTask.one();
8.         CompletableFuture<String> two = asyncCallBackTask.two();
9.         CompletableFuture<String> three = asyncCallBackTask.three();
10.         CompletableFuture.allOf(one, two, three).join();
11.         long endTime = System.currentTimeMillis();
12.         log.info("任务总耗时：" + (endTime - startTime) + "毫秒");
13.     }

复制代码

结果图

同步调用

异步调用
实验完异步调用，只有使命的部分相关输出，使命的实验顺序也是乱序的。

异步回调

异步使命线程池设置

介绍

当我们用异步调用或异步回调进行并发操作时，加速了使命的实验效率，但是假如只是直接简单的创建来使用，可能会碰到一些问题和风险。当接口被频繁调用，异步使命创建的数量到达一定量级，可能会导致内存溢出，此时我们就需要对创建异步使命的操作，加上线程池的相关设置。

queueCapacity：缓冲队列的容量，默认为INT的最大值（2的31次方-1）
maxSize：允许的最大线程数，默认为INT的最大值（2的31次方-1）
具体设置

   application.yml

1. spring:
2.   task:
3.     execution:
4.       pool:
5.         core-size: 2 #线程池创建时的初始化线程数，默认为8
6.         max-size: 5 #线程池的最大线程数，默认为int最大值
7.         queue-capacity: 10 #用来缓冲执行任务的队列，默认为int最大值
8.         keep-alive: 60s #线程终止前允许保持空闲的时间，默认为60s
9.         allow-core-thread-timeout: true #是否允许核心线程超时
10.       shutdown:
11.         await-termination: false #是否等待剩余任务完成后才关闭应用
12.         await-termination-period: #等待剩余任务完成的最大时间
13.       thread-name-prefix: task- #线程名的前缀，设置好了之后可以方便我们在日志中查看处理任务所在的线程池

复制代码

  application.Properties

1. spring.task.execution.pool.core-size=2
2. spring.task.execution.pool.max-size=5
3. spring.task.execution.pool.queue-capacity=10
4. spring.task.execution.pool.keep-alive=60s
5. spring.task.execution.pool.allow-core-thread-timeout=true
6. spring.task.execution.shutdown.await-termination=false
7. spring.task.execution.shutdown.await-termination-period=
8. spring.task.execution.thread-name-prefix=task-

复制代码

结果图

再次实验异步回调方法，得到如下结果图。
当前设置的初始化线程数为2，最大线程数为5，缓存队列为10，只有当缓存队列满且当火线程数小于最大线程数时，才会申请新的线程来实验使命（如：缓存队列为11，初始化线程数为2，最大线程数为5）。

项目结构图

参考资料

Spring Boot 2.x基础教程：使用@Async实现异步调用【https://www.didispace.com/spring-boot-2/8-3-async-1.html】
Spring Boot 2.x基础教程：设置@Async异步使命的线程池【https://www.didispace.com/spring-boot-2/8-3-async-2.html】

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。