Spring Boot中有多个@Async异步任务时，记得做好线程池的隔离！

最新推荐文章于 2023-03-27 14:25:52 发布
最新推荐文章于 2023-03-27 14:25:52 发布
阅读量355 收藏 2
点赞数
分类专栏： java基础教程 文章标签： spring java node.js
原文链接：https://www.cnblogs.com/didispace/p/15307355.html
版权

通过上一篇：配置@Async异步任务的线程池的介绍，你应该已经了解到异步任务的执行背后有一个线程池来管理执行任务。为了控制异步任务的并发不影响到应用的正常运作，我们必须要对线程池做好相应的配置，防止资源的过渡使用。除了默认线程池的配置之外，还有一类场景，也是很常见的，那就是多任务情况下的线程池隔离。

什么是线程池的隔离，为什么要隔离

可能有的小伙伴还不太了解什么是线程池的隔离，为什么要隔离？。所以，我们先来看看下面的场景案例：

@RestController
public class HelloController {

    @Autowired
    private AsyncTasks asyncTasks;
        
    @GetMapping("/api-1")
    public String taskOne() {
        CompletableFuture<String> task1 = asyncTasks.doTaskOne("1");
        CompletableFuture<String> task2 = asyncTasks.doTaskOne("2");
        CompletableFuture<String> task3 = asyncTasks.doTaskOne("3");
        
        CompletableFuture.allOf(task1, task2, task3).join();
        return "";
    }
    
    @GetMapping("/api-2")
    public String taskTwo() {
        CompletableFuture<String> task1 = asyncTasks.doTaskTwo("1");
        CompletableFuture<String> task2 = asyncTasks.doTaskTwo("2");
        CompletableFuture<String> task3 = asyncTasks.doTaskTwo("3");
        
        CompletableFuture.allOf(task1, task2, task3).join();
        return "";
    }
    
}

上面的代码中，有两个API接口，这两个接口的具体执行逻辑中都会把执行过程拆分为三个异步任务来实现。

好了，思考一分钟，想一下。如果这样实现，会有什么问题吗？

上面这段代码，在API请求并发不高，同时如果每个任务的处理速度也够快的时候，是没有问题的。但如果并发上来或其中某几个处理过程扯后腿了的时候。这两个提供不相干服务的接口可能会互相影响。比如：假设当前线程池配置的最大线程数有2个，这个时候/api-1接口中task1和task2处理速度很慢，阻塞了；那么此时，当用户调用api-2接口的时候，这个服务也会阻塞！

造成这种现场的原因是：默认情况下，所有用@Async创建的异步任务都是共用的一个线程池，所以当有一些异步任务碰到性能问题的时候，是会直接影响其他异步任务的。

为了解决这个问题，我们就需要对异步任务做一定的线程池隔离，让不同的异步任务互不影响。

不同异步任务配置不同线程池

下面，我们就来实际操作一下！

第一步：初始化多个线程池，比如下面这样：

@EnableAsync
@Configuration
public class TaskPoolConfig {

    @Bean
    public Executor taskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("executor-1-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    @Bean
    public Executor taskExecutor2() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("executor-2-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

注意：这里特地用executor.setThreadNamePrefix设置了线程名的前缀，这样可以方便观察后面具体执行的顺序。

第二步：创建异步任务，并指定要使用的线程池名称

@Slf4j
@Component
public class AsyncTasks {

    public static Random random = new Random();

    @Async("taskExecutor1")
    public CompletableFuture<String> doTaskOne(String taskNo) throws Exception {
        log.info("开始任务：{}", taskNo);
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("完成任务：{}，耗时：{} 毫秒", taskNo, end - start);
        return CompletableFuture.completedFuture("任务完成");
    }

    @Async("taskExecutor2")
    public CompletableFuture<String> doTaskTwo(String taskNo) throws Exception {
        log.info("开始任务：{}", taskNo);
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("完成任务：{}，耗时：{} 毫秒", taskNo, end - start);
        return CompletableFuture.completedFuture("任务完成");
    }

}

这里@Async注解中定义的taskExecutor1和taskExecutor2就是线程池的名字。由于在第一步中，我们没有具体写两个线程池Bean的名称，所以默认会使用方法名，也就是taskExecutor1和taskExecutor2。

第三步：写个单元测试来验证下，比如下面这样：

@Slf4j
@SpringBootTest
public class Chapter77ApplicationTests {

    @Autowired
    private AsyncTasks asyncTasks;

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

        // 线程池1
        CompletableFuture<String> task1 = asyncTasks.doTaskOne("1");
        CompletableFuture<String> task2 = asyncTasks.doTaskOne("2");
        CompletableFuture<String> task3 = asyncTasks.doTaskOne("3");

        // 线程池2
        CompletableFuture<String> task4 = asyncTasks.doTaskTwo("4");
        CompletableFuture<String> task5 = asyncTasks.doTaskTwo("5");
        CompletableFuture<String> task6 = asyncTasks.doTaskTwo("6");

        // 一起执行
        CompletableFuture.allOf(task1, task2, task3, task4, task5, task6).join();

        long end = System.currentTimeMillis();

        log.info("任务全部完成，总耗时：" + (end - start) + "毫秒");
    }

}

在上面的单元测试中，一共启动了6个异步任务，前三个用的是线程池1，后三个用的是线程池2。

先不执行，根据设置的核心线程2和最大线程数2，来分析一下，大概会是怎么样的执行情况？

  1. 线程池1的三个任务，task1和task2会先获得执行线程，然后task3因为没有可分配线程进入缓冲队列
  2. 线程池2的三个任务，task4和task5会先获得执行线程，然后task6因为没有可分配线程进入缓冲队列
  3. 任务task3会在task1或task2完成之后，开始执行
  4. 任务task6会在task4或task5完成之后，开始执行

分析好之后，执行下单元测试，看看是否是这样的：

2021-09-15 23:45:11.369  INFO 61670 --- [   executor-1-1] com.didispace.chapter77.AsyncTasks       : 开始任务：1
2021-09-15 23:45:11.369  INFO 61670 --- [   executor-2-2] com.didispace.chapter77.AsyncTasks       : 开始任务：5
2021-09-15 23:45:11.369  INFO 61670 --- [   executor-2-1] com.didispace.chapter77.AsyncTasks       : 开始任务：4
2021-09-15 23:45:11.369  INFO 61670 --- [   executor-1-2] com.didispace.chapter77.AsyncTasks       : 开始任务：2
2021-09-15 23:45:15.905  INFO 61670 --- [   executor-2-1] com.didispace.chapter77.AsyncTasks       : 完成任务：4，耗时：4532 毫秒
2021-09-15 23:45:15.905  INFO 61670 --- [   executor-2-1] com.didispace.chapter77.AsyncTasks       : 开始任务：6
2021-09-15 23:45:18.263  INFO 61670 --- [   executor-1-2] com.didispace.chapter77.AsyncTasks       : 完成任务：2，耗时：6890 毫秒
2021-09-15 23:45:18.263  INFO 61670 --- [   executor-1-2] com.didispace.chapter77.AsyncTasks       : 开始任务：3
2021-09-15 23:45:18.896  INFO 61670 --- [   executor-2-2] com.didispace.chapter77.AsyncTasks       : 完成任务：5，耗时：7523 毫秒
2021-09-15 23:45:19.842  INFO 61670 --- [   executor-1-2] com.didispace.chapter77.AsyncTasks       : 完成任务：3，耗时：1579 毫秒
2021-09-15 23:45:20.551  INFO 61670 --- [   executor-1-1] com.didispace.chapter77.AsyncTasks       : 完成任务：1，耗时：9178 毫秒
2021-09-15 23:45:24.117  INFO 61670 --- [   executor-2-1] com.didispace.chapter77.AsyncTasks       : 完成任务：6，耗时：8212 毫秒
2021-09-15 23:45:24.117  INFO 61670 --- [           main] c.d.chapter77.Chapter77ApplicationTests  : 任务全部完成，总耗时：12762毫秒

好了，今天的学java教程习就到这里！

代码示例

本文的完整工程可以查看下面仓库中2.x目录下的chapter7-7工程：

chinaherolts2008
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot使用@Async CompleteableFuture完成多个任务的异步回调
王树伦的博客
12-16 4210
简介 最近对代码进行优化，遇到一个场景：一个方法对多个RPC同时发起调用，每个RPC的响应事件在200ms左右而且是不受控制，有同事使用异步进行了实现，参考网上查的一些资料，大部分是如下这种描述资料地址 回调的核心代码如下 // 三个任务都调用完成，退出循环等待 while (!task1.isDone() || !task2.isDone() || !task3.isDone()) { sleep(1000); } 这种实现不够优雅，...
spring boot中使用@Async实现异步调用任务
08-31
本篇文章主要介绍了spring boot中使用@Async实现异步调用任务，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
主要给大家介绍了关于Spring Boot利用@Async如何实现异步调用：自定义线程池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
Spring Boot 2.x多线程--使用@Async开启多线程使用示例
学亮编程手记
05-15 8755
Spring Boot 2.x多线程–使用@Async开启多线程，配置类+启动类注解，搞定多线程任务。 配置类TaskPoolConfig.java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import ...
spring boot异步(Async)任务调度
热门推荐
牛奋lch
01-18 1万+
前言 在我前面的博客中，多处使用了@Async来实现异步任务调度，具体请参考博客： http://blog.csdn.net/liuchuanhong1/article/details/52326578 http://blog.csdn.net/liuchuanhong1/article/details/52042520 在没有使用spring boot之前，我们的做法是在配置文件中定义一
Springboot实战：@Async开启异步多线程详细教程（附git源码）
dingdingdandan
05-27 1491
Springboot-cli 开发脚手架系列 文章目录Springboot-cli 开发脚手架系列简介1. 环境2. 配置自定义线程池3. 使用4. 效果演示5. 源码分享 简介 在Spring中，使用@Async标注某方法，可以使该方法变成异步方法，这些方法在被调用的时候，将会在独立的线程中进行执行，调用者不需等待该方法执行完成。 在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式 @Async默认异步配置使用的是SimpleAsyncTaskExecutor，该线程池默认来一个任务
SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync）
@素素~的博客
03-11 3126
SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync）1. 前言2. 举例说明2.1 例1——异步不生效例子2.1.1 案例介绍2.1.2 观察效果2.1.3 问题原因及解决办法2.1.4 附代码2.2 例2——解决2.1的异步不生效例子2.2.1 解决方案12.2.1.1 代码2.2.1.2 效果2.2.2 解决方案2——两个异步类里互相调用异步方法2.2.2.1 代码2.2.2.2 效果2.3 例3——使用定义线程池的异步2.4 例4——优化2.3（打印线程池
SpringBoot异步多线程调用注解@Async使用和CountDown
liuyuinsdu的专栏
03-01 1514
关于多线成调用可能大家用的比较多的是JDK的多线程，springboot1.5+,项目框架中集成了异步多线程操作配置，在这里和大家分享一下springboot的异步多线程注解使用,先一步一步来以代码的形式讲解大家可能会遇到的问题。 一：创建方法，然后在方法上添加@Async注解，然后还需要在@SpringBootApplication启动类或者@configure注解类上 添加注解@EnableAsync启动多线程注解，@Async就会对标注的方法开启异步多线程调用，注意，这个方法的类一定要交给spri.
Spring Boot利用@Async异步调用：ThreadPoolTaskScheduler线程池的优雅关闭详解
08-27
主要给大家介绍了关于Spring Boot利用@Async异步调用：ThreadPoolTaskScheduler线程池的优雅关闭的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
Spring Boot @Async 异步任务执行方法
08-27
本篇文章主要介绍了Spring Boot @Async 异步任务执行方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot利用@Async异步调用：使用Future及定义超时详解
08-27
主要给大家介绍了关于Spring Boot利用@Async异步调用：使用Future及定义超时的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用spring boot具有一定的参考学习价值，需要的朋友可以参考下
@Async异步执行
LuckFairyLuckBaby的博客
10-09 1010
springBoot异步执行方法@Async 1.什么是异步调用？ 异步调用是相对于同步调用而言的，同步调用是指程序按预定顺序一步步执行，每一步必须等到上一步执行完后才能执行，异步调用则无需等待上一步程序执行完即可执行。 2.如何实现异步调用？ 多线程，这是很多人第一眼想到的关键词，没错，多线程就是一种实现异步调用的方式。 在非spring目项目中我们要实现异步调用的就是使用多线程方式，...
Springboot使用@Async多线程注解
李小德不晓得的博客
11-06 7162
本文主要讲解 @Async 的基本使用及和 AsyncConfigurer 接口的关系，对于线程池的作用、线程池的参数(核心线程、最大线程......)及运行原理，这里不再过多赘述。
在同一个类中，一个方法调用另外一个有注解（比如@Async，@Transational）的方法，注解失效的原因和解决方法
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
02-08 999
在同一个类中，一个方法调用另外一个有注解（比如@Async，@Transational）的方法，注解失效的原因和解决方法
JAVA类加载隔离
Joker_ZJN的博客
03-27 1353
万字长文拆解类加载隔离机制，包含SpringBoot的类加载机制，tomcat的类加载隔离机制
多线程知识点
佳豪的博客
08-04 543
一、线程启动的两种方式 1.、继承Thread类重写Thread的run方法，在run方法中进行操作，用start方法启动线程 2、继承Runnable接口，实现run方法，在run方法中进行操作，需要传入当前类的实例对象创建一个Thread实例，然后调用start方法启动线程 ...
springboot @Async自定义一个可以顺序执行线程的执行器
JasonYao的程序猿路
03-06 1182
自定义执行器 @EnableAsync @Configuration public class SpringAsyncTaskConfiguration { @Primary @Bean public TaskExecutor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(8);
springboot使用@async实现异步线程池
知识追寻者(Inheriting the spirit of open source, Spreading technology knowledge;)
12-19 732
一 介绍 工作中经常涉及异步任务，通常是使用多线程技术，比如线程池ThreadPoolExecutor，但使用Executors容易产生OOM，需要手动使用ThreadPoolExecutor创建线程池；在springboot使用 @async 可以实现异步调用，配置线程池参数，可以简单的实现多线程的线程池效果，从而简化开发，避免OOM； 二 异步调用 2.1无返回异步 我们知道同步执行就是按照代码的顺序执行，而异步执行则是无序，在springboot中使用实现异步调用函数非常简单，首先在启动类上加上@En
【SpringBoot】SpringBoot中使用线程池@EnableAsync
qgnczmnmn的博客
12-16 1297
涉及到多线程的使用，总会绕不开一个概念——线程池，关于线程的原理及原始代码实现，这里不讲，网上有很多相关的博客，这里直接来介绍一下在SpringBoot中使用线程池来进行多线程的管理。 1、核心参数介绍 1、CorePoolSize：核心线程数，核心线程会一直存活，即使没有任务需要执行 2、MaxPoolSize：线程池中的最大线程数 3、QueueCapacity：阻塞队列的容量，用来存储等...
spring boot @Async异步注解上下文透传 示例
最新发布
06-03
好的，下面是一个简单的示例： 假设我们有一个 UserService，其中有一个方法 sendEmail，它需要异步地发送电子邮件。现在我们想要将当前用户的信息透传给异步任务中使用的线程。 首先，我们需要在异步方法上添加 @Async 注解，并在配置类中启用异步支持： ```java @Configuration @EnableAsync public class AppConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(100); executor.setQueueCapacity(10); executor.initialize(); return executor; } @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return new CustomAsyncExceptionHandler(); } } ``` 在上面的示例中，我们创建了一个 ThreadPoolTaskExecutor，它将用于执行异步任务。我们还实现了 AsyncConfigurer 接口，并覆盖了 getAsyncExecutor 和 getAsyncUncaughtExceptionHandler 方法，以提供自定义的 Executor 和异常处理程序。 现在我们需要将当前用户信息存储在一个 ThreadLocal 对象中。这可以通过一个拦截器来实现： ```java public class UserContextInterceptor extends HandlerInterceptorAdapter { private final ThreadLocal<String> userThreadLocal = new ThreadLocal<>(); @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { String currentUser = request.getHeader("X-User"); userThreadLocal.set(currentUser); return true; } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { userThreadLocal.remove(); } public String getCurrentUser() { return userThreadLocal.get(); } } ``` 在上面的示例中，我们创建了一个 UserContextInterceptor，它将在每个请求的开始和结束时执行。在 preHandle 方法中，我们从请求头中获取当前用户信息，并将其存储在一个 ThreadLocal 对象中。在 afterCompletion 方法中，我们将删除该信息，以避免内存泄漏。 现在，我们可以在 UserService 的 sendEmail 方法中使用 UserContextInterceptor 中存储的当前用户信息： ```java @Service public class UserService { @Autowired private JavaMailSender mailSender; @Autowired private UserContextInterceptor userContextInterceptor; @Async public void sendEmail(String to, String subject, String text) { String currentUser = userContextInterceptor.getCurrentUser(); // 使用当前用户信息发送电子邮件 // ... } } ``` 在上面的示例中，我们使用 @Autowired 注解将 UserContextInterceptor 注入到 UserService 中。在 sendEmail 方法中，我们从 UserContextInterceptor 中获取当前用户信息，并在发送电子邮件时使用它。 通过这种方式，我们可以将当前用户信息透传给异步任务中使用的线程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值