Java多线程开发系列之五:Springboot 中异步请求方法的使用
Springboot 中异步线程的使用
在过往的后台开发中,我们往往使用java自带的线程或线程池,来进行异步的调用。这对于效果来说没什么,甚至可以让开发人员对底层的状况更清晰,但是对于代码的易读性和可维护性却非常的差。
开发人员在实际使用过程中,应该更多的将精力放置在业务代码的书写过程中,而不是系统代码的维护中。你需要懂,但是不需要你直接维护去写,这才是编程语言的风向标。(这也是为什么spring在目前的java开发中,占用比重如此之大的原因之一)
下面来看使用Springboot 来实现异步调用的集中场景
一、简易注解,无需额外配置
1、添加@EnableAsync 到启动类(或者线程池配置类中)
2、添加@Async到需要异步执行的方法中
代码如下:
启动类
1 @EnableAsync
2 @SpringBootApplication
3 public class DemoLearnSpringbootApplication {
4
5 public static void main(String[] args) {
6 SpringApplication.run(DemoLearnSpringbootApplication.class, args);
7 }
8 }
调用类
1 @Component
2 public class SimpleAsyncDemo {
3 @Autowired
4 private SimpleTaskHandler simpleTaskHandler;
5
6
7 @PostConstruct
8 public void execTaskHandler1() {
9 try {
10 simpleTaskHandler.handle1(2);
11 simpleTaskHandler.handle2(2);
12 simpleTaskHandler.handle3(2);
13 simpleTaskHandler.handle1(2);
14 simpleTaskHandler.handle2(2);
15 simpleTaskHandler.handle3(2);
16 simpleTaskHandler.handle1(2);
17 simpleTaskHandler.handle2(2);
18 simpleTaskHandler.handle3(2);
19 } catch (InterruptedException e) {
20 e.printStackTrace();
21 }
22 }
23
24 }
被异步调用的类
1 @Component
2 public class SimpleTaskHandler {
3
4 public void printCurrentTime(String key) {
5 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
6 System.out.println(format.format(new Date()) + "***" + key + "****" + Thread.currentThread().getName());
7 }
8
9 @Async
10 public void handle1(int time) throws InterruptedException {
11 TimeUnit.SECONDS.sleep(time);
12 printCurrentTime("handle1");
13 }
14
15 @Async
16 public void handle2(int time) throws InterruptedException {
17 TimeUnit.SECONDS.sleep(time);
18 printCurrentTime("handle2");
19 }
20
21 @Async
22 public void handle3(int time) throws InterruptedException {
23 TimeUnit.SECONDS.sleep(time);
24 printCurrentTime("handle3");
25 }
26
27
28 }
执行结果
handle1、handle2、handle3的执行结果为乱序,不可预估。这样最简易的通过2个注解即完成异步线程的调用了。
细心的同学已经发现了,连续调用9次异步线程后,最后一次的线程名称就会与之前的重复。这是由于默认的线程池配置的结果。
默认配置如下
# 核心线程数
spring.task.execution.pool.core-size=8
# 最大线程数
spring.task.execution.pool.max-size=16
# 空闲线程存活时间
spring.task.execution.pool.keep-alive=60s
# 是否允许核心线程超时
spring.task.execution.pool.allow-core-thread-timeout=true
# 线程队列数量
spring.task.execution.pool.queue-capacity=100
# 线程关闭等待
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
# 线程名称前缀
spring.task.execution.thread-name-prefix=task-
二、自定义线程池
只通过注解来完成异步线程调用,简单明了,对应的异步线程来自springboot 默认生成的异步线程池。但是有些场景却并不满足。所以我们需要针对业务需要定义自己的线程池配置文件
1、在application.properties中定义我们自己的线程池配置
2、在springboot项目中,添加对应的线程池bean对象
3、添加@EnableAsync 到启动类(或者线程池配置类中)
4、添加@Async到需要异步执行的方法中
代码如下:
application.properties配置文件
task.pool.demo.corePoolSize= 5
task.pool.demo.maxPoolSize= 10
task.pool.demo.keepAliveSeconds= 300
task.pool.demo.queueCapacity= 50
调用类
1 @Component
2 public class SimpleAsyncDemo {
3
4 @Autowired
5 private PoolTaskHandler poolTaskHandler;
6
7
8 @PostConstruct
9 public void execTaskHandler2() {
10 try {
11 poolTaskHandler.handle1(2);
12 poolTaskHandler.handle2(2);
13 poolTaskHandler.handle3(2);
14 poolTaskHandler.handle1(2);
15 poolTaskHandler.handle2(2);
16 poolTaskHandler.handle3(2);
17 poolTaskHandler.handle1(2);
18 poolTaskHandler.handle2(2);
19 poolTaskHandler.handle3(2);
20 } catch (InterruptedException e) {
21 e.printStackTrace();
22 }
23 }
24
25 }
异步线程池的配置类
1 @Configuration
2 public class ThreadPoolConfig {
3
4 @Value("${task.pool.demo.corePoolSize}")
5 private int corePoolSize;
6 @Value("${task.pool.demo.maxPoolSize}")
7 private int maxPoolSize;
8 @Value("${task.pool.demo.queueCapacity}")
9 private int queueCapacity;
10 @Value("${task.pool.demo.keepAliveSeconds}")
11 private int keepAliveSeconds;
12
13
14 @Bean("handleAsync")
15 public TaskExecutor taskExecutor() {
16 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
17 // 设置核心线程数
18 executor.setCorePoolSize(corePoolSize);
19 // 设置最大线程数
20 executor.setMaxPoolSize(maxPoolSize);
21 // 设置队列容量
22 executor.setQueueCapacity(queueCapacity);
23 // 设置线程活跃时间(秒)
24 executor.setKeepAliveSeconds(keepAliveSeconds);
25 // 设置默认线程名称前缀
26 executor.setThreadNamePrefix("Thread-ABC-");
27 // 设置拒绝策略
28 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
29 // 等待所有任务结束后再关闭线程池
30 executor.setWaitForTasksToCompleteOnShutdown(true);
31 return executor;
32 }
33 }
被异步调用的类
1 @Component
2 public class PoolTaskHandler {
3
4 public void printCurrentTime(String key) {
5 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
6 System.out.println(format.format(new Date()) + "***" + key + "****" + Thread.currentThread().getName());
7 }
8
9 @Async("handleAsync")
10 public void handle1(int time) throws InterruptedException {
11 TimeUnit.SECONDS.sleep(time);
12 printCurrentTime("handle-1");
13 }
14
15 @Async("handleAsync")
16 public void handle2(int time) throws InterruptedException {
17 TimeUnit.SECONDS.sleep(time);
18 printCurrentTime("handle-2");
19 }
20
21 @Async("handleAsync")
22 public void handle3(int time) throws InterruptedException {
23 TimeUnit.SECONDS.sleep(time);
24 printCurrentTime("handle-3");
25 }
26
27
28 }
执行结果如下
与上例类似,我们发现请求线程变成了每5个一批,这与我们在配置文件中的配置互相印证
调用类
1 @Component
2 public class SimpleAsyncDemo {
3
4 @Autowired
5 private ReturnTaskHandler returnTaskHandler;
6
7 @PostConstruct
8 public void execTaskHandler3() {
9 try {
10 String a1 = returnTaskHandler.handle1(2);
11 String a2 = returnTaskHandler.handle2(2);
12 String a3 = returnTaskHandler.handle3(2);
13 String a4 = returnTaskHandler.handle1(2);
14 String a5 = returnTaskHandler.handle2(2);
15 String a6 = returnTaskHandler.handle3(2);
16 String a7 = returnTaskHandler.handle1(2);
17 String a8 = returnTaskHandler.handle2(2);
18 String a9 = returnTaskHandler.handle3(2);
19 int c = 1;
20 } catch (InterruptedException e) {
21 e.printStackTrace();
22 }
23 }
24
25 }
被调用类
1 @Component
2 public class ReturnTaskHandler {
3
4 public void printCurrentTime(String key) {
5 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
6 System.out.println(format.format(new Date()) + "***" + key + "****" + Thread.currentThread().getName());
7 }
8
9 @Async("handleAsync")
10 public String handle1(int time) throws InterruptedException {
11 TimeUnit.SECONDS.sleep(time);
12 printCurrentTime("handle-1");
13 return "result1";
14 }
15
16 @Async("handleAsync")
17 public String handle2(int time) throws InterruptedException {
18 TimeUnit.SECONDS.sleep(time);
19 printCurrentTime("handle-2");
20 return "result2";
21 }
22
23 @Async("handleAsync")
24 public String handle3(int time) throws InterruptedException {
25 TimeUnit.SECONDS.sleep(time);
26 printCurrentTime("handle-3");
27 return "result3";
28 }
29
30 }
其余代码继续我们使用上文中的其他代码
结果如下
所有结果返回都是null值。
如果想要拿到正确的执行结果,我们需要使用future接口类看来帮忙接住异步线程的返回结果(关于future等接口类的内容我会在后边的文章中讲解)
其余代码继续我们使用上文中的其他代码,改动的代码如下:
被调用类
1 @Component
2 public class ReturnSuccTaskHandler {
3
4 public void printCurrentTime(String key) {
5 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
6 System.out.println(format.format(new Date()) + "***" + key + "****" + Thread.currentThread().getName());
7 }
8
9 @Async("handleAsync")
10 public Future<String> handle1(int time) throws InterruptedException {
11 TimeUnit.SECONDS.sleep(time);
12 printCurrentTime("handle-1");
13 return new AsyncResult<>("result1");
14 }
15
16 @Async("handleAsync")
17 public Future<String> handle2(int time) throws InterruptedException {
18 TimeUnit.SECONDS.sleep(time);
19 printCurrentTime("handle-2");
20 return new AsyncResult<>("result2");
21 }
22
23 @Async("handleAsync")
24 public Future<String> handle3(int time) throws InterruptedException {
25 TimeUnit.SECONDS.sleep(time);
26 printCurrentTime("handle-3");
27 return new AsyncResult<>("result3");
28 }
29
30
31 }
调用类
1 @Component
2 public class SimpleAsyncDemo {
3
4
5 @Autowired
6 private ReturnSuccTaskHandler returnSuccTaskHandler;
7
8
9
10 @PostConstruct
11 public void execTaskHandler4() {
12 try {
13 Future<String> a1 = returnSuccTaskHandler.handle1(2);
14 Future<String> a2 = returnSuccTaskHandler.handle2(2);
15 Future<String> a3 = returnSuccTaskHandler.handle3(2);
16 Future<String> a4 = returnSuccTaskHandler.handle1(2);
17 Future<String> a5 = returnSuccTaskHandler.handle2(2);
18 Future<String> a6 = returnSuccTaskHandler.handle3(2);
19 Future<String> a7 = returnSuccTaskHandler.handle1(2);
20 Future<String> a8 = returnSuccTaskHandler.handle2(2);
21 Future<String> a9 = returnSuccTaskHandler.handle3(2);
22 while (true){
23 // 如果任务都做完就执行如下逻辑
24 if (a1.isDone() &&
25 a2.isDone()&&
26 a3.isDone()&&
27 a4.isDone()&&
28 a5.isDone()&&
29 a6.isDone()&&
30 a7.isDone()&&
31 a8.isDone()&&
32 a9.isDone()){
33 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
34 System.out.println(format.format(new Date()) + "async task end.");
35 System.out.println("async result:"+a1.get());
36 System.out.println("async result:"+a2.get());
37 System.out.println("async result:"+a3.get());
38 System.out.println("async result:"+a3.get());
39 System.out.println("async result:"+a4.get());
40 System.out.println("async result:"+a5.get());
41 System.out.println("async result:"+a6.get());
42 System.out.println("async result:"+a7.get());
43 System.out.println("async result:"+a8.get());
44 System.out.println("async result:"+a9.get());
45 break;
46 }
47 }
48 } catch (InterruptedException | ExecutionException e) {
49 e.printStackTrace();
50 }
51 }
52
53
54 }
输出结果如下,我们可以发现 ,1、可以拿到返回结果,2、在最后一个子任务执行完成后,即立刻拿到结果。
Java多线程开发系列之五:Springboot 中异步请求方法的使用的更多相关文章
- SpringBoot中异步请求和异步调用(看这一篇就够了)
原创不易,如需转载,请注明出处https://www.cnblogs.com/baixianlong/p/10661591.html,否则将追究法律责任!!! 一.SpringBoot中异步请求的使用 ...
- Java多线程开发系列之四:玩转多线程(线程的控制2)
在上节的线程控制(详情点击这里)中,我们讲解了线程的等待join().守护线程.本节我们将会把剩下的线程控制内容一并讲完,主要内容有线程的睡眠.让步.优先级.挂起和恢复.停止等. 废话不多说,我们直接 ...
- Java多线程开发系列之番外篇:事件派发线程---EventDispatchThread
事件派发线程是java Swing开发中重要的知识点,在安卓app开发中,也是非常重要的一点.今天我们在多线程开发中,穿插进来这个线程.分别从线程的来由.原理和使用方法三个方面来学习事件派发线程. 一 ...
- Java多线程开发系列之一:走进多线程
对编程语言的基础知识:分支.选择.循环.面向对象等基本概念理解后,我们需要对java高级编程有一定的学习,这里不可避免的要接触到多线程开发. 由于多线程开发整体的系统比较大,我会写一个系列的文章总结介 ...
- Java多线程开发系列之二:如何创建多线程
前文已介绍过多线程的基本知识了,比如什么是多线程,什么又是进程,为什么要使用多线程等等. 在了解了软件开发中使用多线程的基本常识后,我们今天来聊聊如何简单的使用多线程. 在Java中创建多线程的方式有 ...
- Java多线程开发系列之四:玩转多线程(线程的控制1)
在前文中我们已经学习了:线程的基本情况.如何创建多线程.线程的生命周期.利用已有知识我们已经可以写出如何利用多线程处理大量任务这样简单的程序.但是当应用场景复杂时,我们还需要从管理控制入手,更好的操纵 ...
- Java多线程开发系列之三:线程这一辈子(线程的生命周期)
前文中已经提到了,关于多线程的基础知识和多线程的创建.但是如果想要很好的管理多线程,一定要对线程的生命周期有一个整体概念.本节即对线程的一生进行介绍,让大家对线程的各个时段的状态有一定了解. 线程的一 ...
- Java多线程开发技巧
很多开发者谈到Java多线程开发,仅仅停留在new Thread(...).start()或直接使用Executor框架这个层面,对于线程的管理和控制却不够深入,通过读<Java并发编程实践&g ...
- [转]Java多线程干货系列—(一)Java多线程基础
Java多线程干货系列—(一)Java多线程基础 字数7618 阅读1875 评论21 喜欢86 前言 多线程并发编程是Java编程中重要的一块内容,也是面试重点覆盖区域,所以学好多线程并发编程对我们 ...
随机推荐
- mybatis if判断等于某个字符串
这种写法是错误的:在OGNL的表达式中,'true'会被解析成字符,因为java是强类型的 <if test="flag=='true' "> AND ho.id = ...
- DOM树
一.DOM树一共有12种节点类型,常用的有4种: 1.Document类型(document节点)--DOM的"入口点" 2.Element节点(元素节点)--HTML标签,树构建 ...
- jenkins 流水线自动化部署 手动下载安装插件包
如果有些插件不能通过可选插件安装,可以进行选择高级并上传插件包,插件包链接地址为:http://updates.jenkins-ci.org/download/plugins/ 同时在高级中可以更换下 ...
- 2021.04.24【NOIP提高B组】模拟 总结
2021.04.24[NOIP提高B组]模拟 总结 T1 题意:有一圈数.两两之间有加法或乘法操作, 问你开始断掉那条边使得剩下的序列经过某种操作后的值最大 看上去是个区间 dp .然后直接断环成列, ...
- 重学ES系列之字符串方面的处理
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- SpringCloud Alibaba整合Sentinel
SpringCloud Alibaba整合Sentinel Sentinel 控制台 1. 概述 Sentinel 提供一个轻量级的开源控制台,它提供机器发现以及健康情况管理.监控(单机和集群),规则 ...
- dotnet 控制台 使用 Microsoft.Maui.Graphics 配合 Skia 进行绘图入门
本文将告诉大家如何在 dotnet 的控制台模式下,采用 MAUI 自绘库 Microsoft.Maui.Graphics 进行绘图,设置 Microsoft.Maui.Graphics 底层调用 M ...
- NC207028 第k小数
NC207028 第k小数 题目 题目描述 给你一个长度为 \(n\) 的序列,求序列中第 \(k\) 小数的多少. 输入描述 多组输入,第一行读入一个整数 \(T\) 表示有 \(T\) 组数据. ...
- StarGAN论文及代码理解
StarGAN的引入是为了解决多领域间的转换问题的,之前的CycleGAN等只能解决两个领域之间的转换,那么对于含有C个领域转换而言,需要学习C*(C-1)个模型,但StarGAN仅需要学习一个,而且 ...
- JSP页面+请求转发+EL表达式
1) JSP全称Java Server Pages,顾名思义就是运行在java服务器中的页面,也就是在我们JavaWeb中的动态页面,其本质就是一个Servlet.2) 其本身是一个动态网页技术标准, ...