SpringBoot 如何异步编程,老鸟们都这么玩的!

发布网友 发布时间：2024-09-26 18:36

我来回答

共1个回答

热心网友 时间：2024-10-04 13:48

大家好，我是飘渺。今天继续给大家带来SpringBoot老鸟系列的第六篇，来聊聊在SpringBoot项目中如何实现异步编程。

首先我们来看看在Spring中为什么要使用异步编程，它能解决什么问题？

为什么要用异步框架，它解决什么问题？

在SpringBoot的日常开发中，一般都是同步调用的。但实际中有很多场景非常适合使用异步来处理，如：注册新用户，送100个积分；或下单成功，发送push消息等等。

就拿注册新用户这个用例来说，为什么要异步处理？

第一个原因：容错性、健壮性，如果送积分出现异常，不能因为送积分而导致用户注册失败； 因为用户注册是主要功能，送积分是次要功能，即使送积分异常也要提示用户注册成功，然后后面在针对积分异常做补偿处理。

第二个原因：提升性能，例如注册用户花了20毫秒，送积分花费50毫秒，如果用同步的话，总耗时70毫秒，用异步的话，无需等待积分，故耗时20毫秒。

故，异步能解决2个问题，性能和容错性。

SpringBoot如何实现异步调用？

对于异步方法调用，从Spring3开始提供了@Async注解，我们只需要在方法上标注此注解，此方法即可实现异步调用。

当然，我们还需要一个配置类，通过Enable模块驱动注解@EnableAsync 来开启异步功能。

实现异步调用第一步：新建配置类，开启@Async功能支持

使用@EnableAsync来开启异步任务支持，@EnableAsync注解可以直接放在SpringBoot启动类上，也可以单独放在其他配置类上。我们这里选择使用单独的配置类SyncConfiguration。

@Configuration@EnableAsyncpublicclassAsyncConfiguration{}第二步：在方法上标记异步调用

增加一个Component类，用来进行业务处理，同时添加@Async注解，代表该方法为异步处理。

@Component@Slf4jpublicclassAsyncTask{@SneakyThrows@AsyncpublicvoiddoTask1(){longt1=System.currentTimeMillis();Thread.sleep(2000);longt2=System.currentTimeMillis();log.info("task1cost{}ms",t2-t1);}@SneakyThrows@AsyncpublicvoiddoTask2(){longt1=System.currentTimeMillis();Thread.sleep(3000);longt2=System.currentTimeMillis();log.info("task2cost{}ms",t2-t1);}}第三步：在Controller中进行异步方法调用@RestController@RequestMapping("/async")@Slf4jpublicclassAsyncController{@AutowiredprivateAsyncTaskasyncTask;@RequestMapping("/task")publicvoidtask()throwsInterruptedException{longt1=System.currentTimeMillis();asyncTask.doTask1();asyncTask.doTask2();Thread.sleep(1000);longt2=System.currentTimeMillis();log.info("maincost{}ms",t2-t1);}}

通过访问http://localhost:8080/async/task查看控制台日志：

2021-11-2515:48:37[http-nio-8080-exec-8]INFOcom.jianzh5.blog.async.AsyncController:26-maincost1009ms2021-11-2515:48:38[task-1]INFOcom.jianzh5.blog.async.AsyncTask:22-task1cost2005ms2021-11-2515:48:39[task-2]INFOcom.jianzh5.blog.async.AsyncTask:31-task2cost3005ms

通过日志可以看到：主线程不需要等待异步方法执行完成，减少响应时间，提高接口性能。

通过上面三步我们就可以在SpringBoot中欢乐的使用异步方法来提高我们接口性能了，是不是很简单？

不过，如果真实项目中你真这样写了，肯定会被老鸟们无情嘲讽，就这？

因为上面的代码忽略了一个最大的问题，就是给@Async异步框架自定义线程池。

为什么要给@Async自定义线程池？

使用@Async注解，在默认情况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池。

使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误，关键代码如下：

publicvoidexecute(Runnabletask,longstartTimeout){Assert.notNull(task,"Runnablemustnotbenull");RunnabletaskToUse=this.taskDecorator!=null?this.taskDecorator.decorate(task):task;//判断是否开启限流，默认为否if(this.isThrottleActive()&&startTimeout>0L){//执行前置操作，进行限流this.concurrencyThrottle.beforeAccess();this.doExecute(newSimpleAsyncTaskExecutor.ConcurrencyThrottlingRunnable(taskToUse));}else{//未限流的情况，执行线程任务this.doExecute(taskToUse);}}protectedvoiddoExecute(Runnabletask){//不断创建线程Threadthread=this.threadFactory!=null?this.threadFactory.newThread(task):this.createThread(task);thread.start();}//创建线程publicThreadcreateThread(Runnablerunnable){//指定线程名，task-1，task-2...Threadthread=newThread(this.getThreadGroup(),runnable,this.nextThreadName());thread.setPriority(this.getThreadPriority());thread.setDaemon(this.isDaemon());returnthread;}

我们也可以直接通过上面的控制台日志观察，每次打印的线程名都是[task-1]、[task-2]、[task-3]、[task-4].....递增的。

正因如此，所以我们在使用Spring中的@Async异步框架时一定要自定义线程池，替代默认的SimpleAsyncTaskExecutor。

Spring提供了多种线程池：

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。

SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地

ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类

ThreadPoolTaskScheduler：可以使用cron表达式

ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装

为@Async实现一个自定义线程池@Configuration@EnableAsyncpublicclassSyncConfiguration{@Bean(name="asyncPoolTaskExecutor")publicThreadPoolTaskExecutorexecutor(){ThreadPoolTaskExecutortaskExecutor=newThreadPoolTaskExecutor();//核心线程数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(newThreadPoolExecutor.CallerRunsPolicy());taskExecutor.initialize();returntaskExecutor;}}

自定义线程池以后我们就可以大胆的使用@Async提供的异步处理能力了。

多个线程池处理

在现实的互联网项目开发中，针对高并发的请求，一般的做法是高并发接口单独线程池隔离处理。

假设现在2个高并发接口： 一个是修改用户信息接口，刷新用户redis缓存； 一个是下订单接口，发送app push信息。往往会根据接口特征定义两个线程池，这时候我们在使用@Async时就需要通过指定线程池名称进行区分。

为@Async指定线程池名字@SneakyThrows@Async("asyncPoolTaskExecutor")publicvoiddoTask1(){longt1=System.currentTimeMillis();Thread.sleep(2000);longt2=System.currentTimeMillis();log.info("task1cost{}ms",t2-t1);}

当系统存在多个线程池时，我们也可以配置一个默认线程池，对于非默认的异步任务再通过@Async("otherTaskExecutor")来指定线程池名称。

配置默认线程池

可以修改配置类让其实现AsyncConfigurer，并重写getAsyncExecutor()方法，指定默认线程池：

@Configuration@EnableAsync@Slf4jpublicclassAsyncConfigurationimplementsAsyncConfigurer{@Bean(name="asyncPoolTaskExecutor")publicThreadPoolTaskExecutorexecutor(){ThreadPoolTaskExecutortaskExecutor=newThreadPoolTaskExecutor();//核心线程数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(newThreadPoolExecutor.CallerRunsPolicy());taskExecutor.initialize();returntaskExecutor;}/***指定默认线程池*/@OverridepublicExecutorgetAsyncExecutor(){returnexecutor();}@OverridepublicAsyncUncaughtExceptionHandlergetAsyncUncaughtExceptionHandler(){return(ex,method,params)->log.error("线程池执行任务发送未知错误,执行方法：{}",method.getName(),ex);}}

如下，doTask1()方法使用默认使用线程池asyncPoolTaskExecutor，doTask2()使用线程池otherTaskExecutor，非常灵活。

@AsyncpublicvoiddoTask1(){longt1=System.currentTimeMillis();Thread.sleep(2000);longt2=System.currentTimeMillis();log.info("task1cost{}ms",t2-t1);}@SneakyThrows@Async("otherTaskExecutor")publicvoiddoTask2(){longt1=System.currentTimeMillis();Thread.sleep(3000);longt2=System.currentTimeMillis();log.info("task2cost{}ms",t2-t1);}小结

@Async异步方法在日常开发中经常会用到，大家好好掌握，争取早日成为老鸟！！！

tips : 老鸟系列源码已经上传至GitHub，需要的关注本公众号JAVA日知录并回复关键字 0923 获取源码地址。

热心网友 时间：2024-10-04 13:49

大家好，我是飘渺。今天继续给大家带来SpringBoot老鸟系列的第六篇，来聊聊在SpringBoot项目中如何实现异步编程。

首先我们来看看在Spring中为什么要使用异步编程，它能解决什么问题？

为什么要用异步框架，它解决什么问题？

在SpringBoot的日常开发中，一般都是同步调用的。但实际中有很多场景非常适合使用异步来处理，如：注册新用户，送100个积分；或下单成功，发送push消息等等。

就拿注册新用户这个用例来说，为什么要异步处理？

第一个原因：容错性、健壮性，如果送积分出现异常，不能因为送积分而导致用户注册失败； 因为用户注册是主要功能，送积分是次要功能，即使送积分异常也要提示用户注册成功，然后后面在针对积分异常做补偿处理。

第二个原因：提升性能，例如注册用户花了20毫秒，送积分花费50毫秒，如果用同步的话，总耗时70毫秒，用异步的话，无需等待积分，故耗时20毫秒。

故，异步能解决2个问题，性能和容错性。

SpringBoot如何实现异步调用？

对于异步方法调用，从Spring3开始提供了@Async注解，我们只需要在方法上标注此注解，此方法即可实现异步调用。

当然，我们还需要一个配置类，通过Enable模块驱动注解@EnableAsync 来开启异步功能。

实现异步调用第一步：新建配置类，开启@Async功能支持

使用@EnableAsync来开启异步任务支持，@EnableAsync注解可以直接放在SpringBoot启动类上，也可以单独放在其他配置类上。我们这里选择使用单独的配置类SyncConfiguration。

@Configuration@EnableAsyncpublicclassAsyncConfiguration{}第二步：在方法上标记异步调用

增加一个Component类，用来进行业务处理，同时添加@Async注解，代表该方法为异步处理。

@Component@Slf4jpublicclassAsyncTask{@SneakyThrows@AsyncpublicvoiddoTask1(){longt1=System.currentTimeMillis();Thread.sleep(2000);longt2=System.currentTimeMillis();log.info("task1cost{}ms",t2-t1);}@SneakyThrows@AsyncpublicvoiddoTask2(){longt1=System.currentTimeMillis();Thread.sleep(3000);longt2=System.currentTimeMillis();log.info("task2cost{}ms",t2-t1);}}第三步：在Controller中进行异步方法调用@RestController@RequestMapping("/async")@Slf4jpublicclassAsyncController{@AutowiredprivateAsyncTaskasyncTask;@RequestMapping("/task")publicvoidtask()throwsInterruptedException{longt1=System.currentTimeMillis();asyncTask.doTask1();asyncTask.doTask2();Thread.sleep(1000);longt2=System.currentTimeMillis();log.info("maincost{}ms",t2-t1);}}

通过访问http://localhost:8080/async/task查看控制台日志：

2021-11-2515:48:37[http-nio-8080-exec-8]INFOcom.jianzh5.blog.async.AsyncController:26-maincost1009ms2021-11-2515:48:38[task-1]INFOcom.jianzh5.blog.async.AsyncTask:22-task1cost2005ms2021-11-2515:48:39[task-2]INFOcom.jianzh5.blog.async.AsyncTask:31-task2cost3005ms

通过日志可以看到：主线程不需要等待异步方法执行完成，减少响应时间，提高接口性能。

通过上面三步我们就可以在SpringBoot中欢乐的使用异步方法来提高我们接口性能了，是不是很简单？

不过，如果真实项目中你真这样写了，肯定会被老鸟们无情嘲讽，就这？

因为上面的代码忽略了一个最大的问题，就是给@Async异步框架自定义线程池。

为什么要给@Async自定义线程池？

使用@Async注解，在默认情况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池。

使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误，关键代码如下：

publicvoidexecute(Runnabletask,longstartTimeout){Assert.notNull(task,"Runnablemustnotbenull");RunnabletaskToUse=this.taskDecorator!=null?this.taskDecorator.decorate(task):task;//判断是否开启限流，默认为否if(this.isThrottleActive()&&startTimeout>0L){//执行前置操作，进行限流this.concurrencyThrottle.beforeAccess();this.doExecute(newSimpleAsyncTaskExecutor.ConcurrencyThrottlingRunnable(taskToUse));}else{//未限流的情况，执行线程任务this.doExecute(taskToUse);}}protectedvoiddoExecute(Runnabletask){//不断创建线程Threadthread=this.threadFactory!=null?this.threadFactory.newThread(task):this.createThread(task);thread.start();}//创建线程publicThreadcreateThread(Runnablerunnable){//指定线程名，task-1，task-2...Threadthread=newThread(this.getThreadGroup(),runnable,this.nextThreadName());thread.setPriority(this.getThreadPriority());thread.setDaemon(this.isDaemon());returnthread;}

我们也可以直接通过上面的控制台日志观察，每次打印的线程名都是[task-1]、[task-2]、[task-3]、[task-4].....递增的。

正因如此，所以我们在使用Spring中的@Async异步框架时一定要自定义线程池，替代默认的SimpleAsyncTaskExecutor。

Spring提供了多种线程池：

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。

SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地

ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类

ThreadPoolTaskScheduler：可以使用cron表达式

ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装

为@Async实现一个自定义线程池@Configuration@EnableAsyncpublicclassSyncConfiguration{@Bean(name="asyncPoolTaskExecutor")publicThreadPoolTaskExecutorexecutor(){ThreadPoolTaskExecutortaskExecutor=newThreadPoolTaskExecutor();//核心线程数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(newThreadPoolExecutor.CallerRunsPolicy());taskExecutor.initialize();returntaskExecutor;}}

自定义线程池以后我们就可以大胆的使用@Async提供的异步处理能力了。

多个线程池处理

在现实的互联网项目开发中，针对高并发的请求，一般的做法是高并发接口单独线程池隔离处理。

假设现在2个高并发接口： 一个是修改用户信息接口，刷新用户redis缓存； 一个是下订单接口，发送app push信息。往往会根据接口特征定义两个线程池，这时候我们在使用@Async时就需要通过指定线程池名称进行区分。

为@Async指定线程池名字@SneakyThrows@Async("asyncPoolTaskExecutor")publicvoiddoTask1(){longt1=System.currentTimeMillis();Thread.sleep(2000);longt2=System.currentTimeMillis();log.info("task1cost{}ms",t2-t1);}

当系统存在多个线程池时，我们也可以配置一个默认线程池，对于非默认的异步任务再通过@Async("otherTaskExecutor")来指定线程池名称。

配置默认线程池

可以修改配置类让其实现AsyncConfigurer，并重写getAsyncExecutor()方法，指定默认线程池：

@Configuration@EnableAsync@Slf4jpublicclassAsyncConfigurationimplementsAsyncConfigurer{@Bean(name="asyncPoolTaskExecutor")publicThreadPoolTaskExecutorexecutor(){ThreadPoolTaskExecutortaskExecutor=newThreadPoolTaskExecutor();//核心线程数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(newThreadPoolExecutor.CallerRunsPolicy());taskExecutor.initialize();returntaskExecutor;}/***指定默认线程池*/@OverridepublicExecutorgetAsyncExecutor(){returnexecutor();}@OverridepublicAsyncUncaughtExceptionHandlergetAsyncUncaughtExceptionHandler(){return(ex,method,params)->log.error("线程池执行任务发送未知错误,执行方法：{}",method.getName(),ex);}}

如下，doTask1()方法使用默认使用线程池asyncPoolTaskExecutor，doTask2()使用线程池otherTaskExecutor，非常灵活。

@AsyncpublicvoiddoTask1(){longt1=System.currentTimeMillis();Thread.sleep(2000);longt2=System.currentTimeMillis();log.info("task1cost{}ms",t2-t1);}@SneakyThrows@Async("otherTaskExecutor")publicvoiddoTask2(){longt1=System.currentTimeMillis();Thread.sleep(3000);longt2=System.currentTimeMillis();log.info("task2cost{}ms",t2-t1);}小结

@Async异步方法在日常开发中经常会用到，大家好好掌握，争取早日成为老鸟！！！

tips : 老鸟系列源码已经上传至GitHub，需要的关注本公众号JAVA日知录并回复关键字 0923 获取源码地址。