SpringBoot 如何实现异步编程
⽬录
为什么要⽤异步框架，它解决什么问题？
SpringBoot如何实现异步调⽤？
实现异步调⽤
为什么要给@Async⾃定义线程池？
多个线程池处理
配置默认线程池
⼩结
⾸先我们来看看在Spring中为什么要使⽤异步编程，它能解决什么问题？
为什么要⽤异步框架，它解决什么问题？
在SpringBoot的⽇常开发中，⼀般都是同步调⽤的。但实际中有很多场景⾮常适合使⽤异步来处理，如：注册新⽤户，送100个积分；或下单成功，发送push消息等等。
就拿注册新⽤户这个⽤例来说，为什么要异步处理？
第⼀个原因：容错性、健壮性，如果送积分出现异常，不能因为送积分⽽导致⽤户注册失败；springboot框架的作用
因为⽤户注册是主要功能，送积分是次要功能，即使送积分异常也要提⽰⽤户注册成功，然后后⾯在针对积分异常做补偿处理。
第⼆个原因：提升性能，例如注册⽤户花了20毫秒，送积分花费50毫秒，如果⽤同步的话，总耗时70毫秒，⽤异步的话，⽆需等待积分，故耗时20毫秒。
故，异步能解决2个问题，性能和容错性。
SpringBoot如何实现异步调⽤？
对于异步⽅法调⽤，从Spring3开始提供了@Async注解，我们只需要在⽅法上标注此注解，此⽅法即可实现异步调⽤。
当然，我们还需要⼀个配置类，通过Enable模块驱动注解@EnableAsync 来开启异步功能。
实现异步调⽤
第⼀步：新建配置类，开启@Async功能⽀持
使⽤@EnableAsync来开启异步任务⽀持，@EnableAsync注解可以直接放在SpringBoot启动类上，也可以单独放在其他配置类上。我们这⾥选择使⽤单独的配置类SyncConfiguration。
@Configuration
@EnableAsync
public class AsyncConfiguration {
}
第⼆步：在⽅法上标记异步调⽤
增加⼀个Component类，⽤来进⾏业务处理，同时添加@Async注解，代表该⽅法为异步处理。
@Component
@Slf4j
public class AsyncTask {
@SneakyThrows
@Async
public void doTask1() {
long t1 = System.currentTimeMillis();
Thread.sleep(2000);
long t2 = System.currentTimeMillis();
log.info("task1 cost {} ms" , t2-t1);
}
@SneakyThrows
@Async
public void doTask2() {
long t1 = System.currentTimeMillis();
Thread.sleep(3000);
long t2 = System.currentTimeMillis();
log.info("task2 cost {} ms" , t2-t1);
}
}
第三步：在Controller中进⾏异步⽅法调⽤
@RestController
@RequestMapping("/async")
@Slf4j
public class AsyncController {
@Autowired
private AsyncTask asyncTask;
@RequestMapping("/task")
public void task() throws InterruptedException {
long t1 = System.currentTimeMillis();
asyncTask.doTask1();
asyncTask.doTask2();
Thread.sleep(1000);
long t2 = System.currentTimeMillis();
log.info("main cost {} ms", t2-t1);
}
}
2021-11-25 15:48:37 [http-nio-8080-exec-8] INFO com.jianzh5.blog.async.AsyncController:26 - main cost 1009
ms
2021-11-25 15:48:38 [task-1] INFO com.jianzh5.blog.async.AsyncTask:22 - task1 cost 2005 ms
2021-11-25 15:48:39 [task-2] INFO com.jianzh5.blog.async.AsyncTask:31 - task2 cost 3005 ms
通过⽇志可以看到：主线程不需要等待异步⽅法执⾏完成，减少响应时间，提⾼接⼝性能。
通过上⾯三步我们就可以在SpringBoot中欢乐的使⽤异步⽅法来提⾼我们接⼝性能了，是不是很简单？
不过，如果真实项⽬中你真这样写了，肯定会被⽼鸟们⽆情嘲讽，就这？
因为上⾯的代码忽略了⼀个最⼤的问题，就是给@Async异步框架⾃定义线程池。
为什么要给@Async⾃定义线程池？
使⽤@Async注解，在默认情况下⽤的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池。
使⽤此线程池⽆法实现线程重⽤，每次调⽤都会新建⼀条线程。若系统中不断的创建线程，最终会导致系统占⽤内存过⾼，引发OutOfMemoryError错误，关键代码如下：
public void execute(Runnable task, long startTimeout) {
Runnable taskToUse = this.taskDecorator != null ? this.taskDecorator.decorate(task) : task;
//判断是否开启限流，默认为否
if (this.isThrottleActive() && startTimeout > 0L) {
//执⾏前置操作，进⾏限流
this.doExecute(new SimpleAsyncTaskExecutor.ConcurrencyThrottlingRunnable(taskToUse));
} else {
//未限流的情况，执⾏线程任务
this.doExecute(taskToUse);
}
}
protected void doExecute(Runnable task) {
//不断创建线程
Thread thread = this.threadFactory != null ? wThread(task) : ateThread(task);
thread.start();
}
//创建线程
public Thread createThread(Runnable runnable) {
//指定线程名，task-1，
Thread thread = new ThreadGroup(), runnable, ThreadName());
thread.ThreadPriority());
thread.setDaemon(this.isDaemon());
return thread;
}
我们也可以直接通过上⾯的控制台⽇志观察，每次打印的线程名都是[task-1]、[task-2]、[task-3]、[task-4].....递增的。
正因如此，所以我们在使⽤Spring中的@Async异步框架时⼀定要⾃定义线程池，替代默认的SimpleAsyncTaskExecutor。
Spring提供了多种线程池：
SimpleAsyncTaskExecutor：不是真的线程池，这个类不重⽤线程，每次调⽤都会创建⼀个新的线程。
SyncTaskExecutor：这个类没有实现异步调⽤，只是⼀个同步操作。只适⽤于不需要多线程的地
ConcurrentTaskExecutor：Executor的适配类，不推荐使⽤。如果ThreadPoolTaskExecutor不满⾜要求时，才⽤考虑使⽤这个类
ThreadPoolTaskScheduler：可以使⽤cron表达式
ThreadPoolTaskExecutor ：最常使⽤，推荐。其实质是对urrent.ThreadPoolExecutor的包装
为@Async实现⼀个⾃定义线程池
@Configuration
@EnableAsync
public class SyncConfiguration {
@Bean(name = "asyncPoolTaskExecutor")
public ThreadPoolTaskExecutor executor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
//核⼼线程数
taskExecutor.setCorePoolSize(10);
//线程池维护线程的最⼤数量，只有在缓冲队列满了之后才会申请超过核⼼线程数的线程
taskExecutor.setMaxPoolSize(100);
//缓存队列
taskExecutor.setQueueCapacity(50);
//许的空闲时间，当超过了核⼼线程出之外的线程在空闲时间到达之后会被销毁
taskExecutor.setKeepAliveSeconds(200);
//异步⽅法内部线程名称
taskExecutor.setThreadNamePrefix("async-");
/**
* 当线程池的任务缓存队列已满并且线程池中的线程数⽬达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
* 通常有以下四种策略：
* ThreadPoolExecutor.AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
* ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
* ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前⾯的任务，然后重新尝试执⾏任务（重复此过程）
* ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，⾃动重复调⽤ execute() ⽅法，直到
成功
*/
taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
taskExecutor.initialize();
return taskExecutor;
}
}
⾃定义线程池以后我们就可以⼤胆的使⽤@Async提供的异步处理能⼒了。
多个线程池处理
在现实的互联⽹项⽬开发中，针对⾼并发的请求，⼀般的做法是⾼并发接⼝单独线程池隔离处理。
假设现在2个⾼并发接⼝：⼀个是修改⽤户信息接⼝，刷新⽤户redis缓存；⼀个是下订单接⼝，发送a
pp push信息。往往会根据接⼝特征定义两个线程池，这时候我们在使⽤@Async时就需要通过指定线程池名称进⾏区分。
为@Async指定线程池名字
@SneakyThrows
@Async("asyncPoolTaskExecutor")
public void doTask1() {
long t1 = System.currentTimeMillis();
Thread.sleep(2000);
long t2 = System.currentTimeMillis();
log.info("task1 cost {} ms" , t2-t1);
}
当系统存在多个线程池时，我们也可以配置⼀个默认线程池，对于⾮默认的异步任务再通过@Async("otherTaskExecutor")来指定线程池名称。
配置默认线程池
可以修改配置类让其实现AsyncConfigurer，并重写getAsyncExecutor()⽅法，指定默认线程池：
@Configuration
@EnableAsync
@Slf4j
public class AsyncConfiguration implements AsyncConfigurer {
@Bean(name = "asyncPoolTaskExecutor")
public ThreadPoolTaskExecutor executor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
//核⼼线程数
taskExecutor.setCorePoolSize(2);
//线程池维护线程的最⼤数量，只有在缓冲队列满了之后才会申请超过核⼼线程数的线程
taskExecutor.setMaxPoolSize(10);
//缓存队列
taskExecutor.setQueueCapacity(50);
//许的空闲时间，当超过了核⼼线程出之外的线程在空闲时间到达之后会被销毁
taskExecutor.setKeepAliveSeconds(200);
//异步⽅法内部线程名称
taskExecutor.setThreadNamePrefix("async-");
/**
* 当线程池的任务缓存队列已满并且线程池中的线程数⽬达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
* 通常有以下四种策略：
* ThreadPoolExecutor.AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
* ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
* ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前⾯的任务，然后重新尝试执⾏任务（重复此过程）
* ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，⾃动重复调⽤ execute() ⽅法，直到成功
*/
taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
taskExecutor.initialize();
return taskExecutor;
}
/**
* 指定默认线程池
*/
@Override
public Executor getAsyncExecutor() {
return executor();
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return (ex, method, params) ->
<("线程池执⾏任务发送未知错误，执⾏⽅法：{}",Name(),ex);
}
}
如下，doTask1()⽅法使⽤默认使⽤线程池asyncPoolTaskExecutor，doTask2()使⽤线程池otherTaskExecutor，⾮常灵活。@Async
public void doTask1() {
long t1 = System.currentTimeMillis();
Thread.sleep(2000);
long t2 = System.currentTimeMillis();
log.info("task1 cost {} ms" , t2-t1);
}
@SneakyThrows
@Async("otherTaskExecutor")
public void doTask2() {
long t1 = System.currentTimeMillis();
Thread.sleep(3000);
long t2 = System.currentTimeMillis();
log.info("task2 cost {} ms" , t2-t1);
}
⼩结
@Async异步⽅法在⽇常开发中经常会⽤到，⼤家好好掌握，争取早⽇成为⽼鸟
到此这篇关于SpringBoot 如何实现异步编程的⽂章就介绍到这了，更多相关SpringBoot 异步编程内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论