devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

@Async详解（二）

作者：小丑西瓜9 | 2024-02-18 00:08:10

赞

踩

@async

Spring异步注解@Async

@Async为什么要使用自定义线程池

通过上一篇对@Async的初步分析，我们可以知道当使用@Async不指定线程池时，Spring会默认使用SimpleAsyncTaskExecutor线程池，那么SimpleAsyncTaskExecutor有什么缺点呢？下面我们通过源码分析SimpleAsyncTaskExecutor为什么不建议使用。

SimpleAsyncTaskExecutor

此类特点概括为以下几点：

  • 为每个任务启动一个新线程，异步执行它。

  • 支持通过“concurrencyLimit”bean 属性限制并发线程。默认情况下，并发线程数是无限的。

  • 注意：此实现不重用线程！

  • 考虑一个线程池 TaskExecutor 实现，特别是用于执行大量短期任务。

默认情况下，SimpleAsyncTaskExecutor不会限制线程创建的个数，这会导致资源耗尽。这个线程池和我们印象中的的线程池可以说是相悖的。如果需要使用SimpleAsyncTaskExecutor，则需指定线程上限(调用setConcurrencyLimit方法)，避免在极端情况下出现资源耗尽的问题。另外，该任务执行器并没有执行拒绝策略，这也是在线上环境需谨慎使用的原因之一。

@Async使用自定义线程池

自定义线程池配置：

  1.  
  2. @Slf4j
  3. @Configuration
  4. @EnableConfigurationProperties({TaskExecutorProperties.class,ExportExecutorProperties.class})
  5. public class ExecutePoolConfig {
  6.  
  7.     // 普通任务线程池配置
  8.     private final TaskExecutorProperties taskExecutorProperties;
  9.  
  10.     // 导出任务线程池配置
  11.     private final ExportExecutorProperties exportExecutorProperties;
  12.  
  13.     @Autowired
  14.     public ExecutePoolConfig(TaskExecutorProperties taskExecutorProperties,ExportExecutorProperties exportExecutorProperties) {
  15.         this.taskExecutorProperties = taskExecutorProperties;
  16.         this.exportExecutorProperties = exportExecutorProperties;
  17.     }
  18.  
  19.     @Bean("taskExecutor")
  20.     public Executor taskExecutor() {
  21.         return buildExecutor(taskExecutorProperties);
  22.     }
  23.     @Bean("exportExecutor")
  24.     public Executor exportExecutor() {
  25.         return buildExecutor(exportExecutorProperties);
  26.     }
  27.  
  28.     /**
  29.      * 构建线程池
  30.      *
  31.      * @param executorProperties ExecutorBaseProperties
  32.      * @return {@link Executor}
  33.      */
  34.     private Executor buildExecutor(ExecutorBaseProperties executorProperties) {
  35.  
  36.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
  37.  
  38.         // 设置核心线程数
  39.         executor.setCorePoolSize(executorProperties.getCorePoolSize());
  40.  
  41.         // 设置最大线程数
  42.         executor.setMaxPoolSize(executorProperties.getMaxPoolSize());
  43.  
  44.         // 设置队列大小
  45.         executor.setQueueCapacity(executorProperties.getQueueCapacity());
  46.  
  47.         // 设置线程池维护线程所允许的空闲时间
  48.         executor.setKeepAliveSeconds(executorProperties.getKeepAliveSeconds());
  49.  
  50.         // 设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean
  51.         executor.setWaitForTasksToCompleteOnShutdown(true);
  52.  
  53.         // 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁
  54.         executor.setAwaitTerminationSeconds(30);
  55.  
  56.         // 设置线程池中的线程的名称前缀
  57.         executor.setThreadNamePrefix(executorProperties.getThreadNamePrefix());
  58.  
  59.         // rejection-policy：当pool已经达到max size的时候，如何处理新任务
  60.         // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
  61.         RejectedExecutionHandler rejectedExecutionHandler = null;
  62.  
  63.         try {
  64.  
  65.             Class<?> clazz = Class
  66.                 .forName("java.util.concurrent.ThreadPoolExecutor$" + executorProperties.getRejectionPolicyName());
  67.             rejectedExecutionHandler = (RejectedExecutionHandler)clazz.newInstance();
  68.  
  69.         } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
  70.             log.error("获取rejection-policy异常，请查看配置文件", e);
  71.             return null;
  72.  
  73.         }
  74.  
  75.         executor.setRejectedExecutionHandler(rejectedExecutionHandler);
  76.         // 执行初始化
  77.         executor.initialize();
  78.         return executor;
  79.  
  80.     }
  81. }
  82.  
  83. @Data
  84. @Component
  85. @ConfigurationProperties(prefix = "task.executor.conf")
  86. public class TaskExecutorProperties extends ExecutorBaseProperties {
  87.  
  88.     /**
  89.      * 核心线程数
  90.      */
  91.     private int corePoolSize = 10;
  92.  
  93.     /**
  94.      * 最大线程数
  95.      */
  96.     private int maxPoolSize = 20;
  97.  
  98.     /**
  99.      * 队列大小
  100.      */
  101.     private int queueCapacity = 200;
  102.  
  103.     /**
  104.      * 线程池维护线程所允许的空闲时间
  105.      */
  106.     private int keepAliveSeconds = 60;
  107.  
  108.     /**
  109.      * 线程的名称前缀
  110.      */
  111.     private String threadNamePrefix = "taskExecutor-";
  112.  
  113.     /**
  114.      * 拒绝策略
  115.      */
  116.     private String rejectionPolicyName = "CallerRunsPolicy";
  117.  
  118. }
  119. @Data
  120. public class ExecutorBaseProperties {
  121.  
  122.     /**
  123.      * 核心线程数
  124.      */
  125.     private int corePoolSize = 10;
  126.  
  127.     /**
  128.      * 最大线程数
  129.      */
  130.     private int maxPoolSize = 20;
  131.  
  132.     /**
  133.      * 队列大小
  134.      */
  135.     private int queueCapacity = 200;
  136.  
  137.     /**
  138.      * 线程池维护线程所允许的空闲时间
  139.      */
  140.     private int keepAliveSeconds = 60;
  141.  
  142.     /**
  143.      * 线程的名称前缀
  144.      */
  145.     private String threadNamePrefix = "taskExecutor-";
  146.  
  147.     /**
  148.      * 拒绝策略
  149.      */
  150.     private String rejectionPolicyName = "CallerRunsPolicy";
  151.  
  152. }

线程池的使用：

  1. @RestController
  2. public class TestController {
  3.  
  4.     @Resource
  5.     private AsyncTestService asyncTestService;
  6.  
  7.     @RequestMapping("/exportTest")
  8.     public String exportTest() {
  9.         System.out.println("父线程userId：" + UserUtils.getUserId());
  10.         System.out.println("父线程traceId：" + MDC.get("traceId"));
  11.         for (int i = 0; i < 10; i++) {
  12.             asyncTestService.exportTest();
  13.         }
  14.         return "OK";
  15.     }
  16.  
  17.     @RequestMapping("/taskTest")
  18.     public String taskTest() {
  19.         for (int i = 0; i < 10; i++) {
  20.             asyncTestService.taskTest();
  21.         }
  22.         return "OK";
  23.     }
  24.  
  25. }
  26.  
  27. public interface AsyncTestService {
  28.     /**
  29.      * exportTest
  30.      */
  31.     void exportTest();
  32.  
  33.     /**
  34.      * taskTest
  35.      */
  36.     void taskTest();
  37. }
  38.  
  39. @Service
  40. public class AsyncTestServiceImpl implements AsyncTestService {
  41.  
  42.     @Async("exportExecutor")
  43.     @Override
  44.     public void exportTest() {
  45.         System.out.println("子线程userId：" + UserUtils.getUserId());
  46.         System.out.println("子线程traceId："  + MDC.get("traceId"));
  47.         System.out.println("我是自定义类型的线程池：" + Thread.currentThread().getName());
  48.     }
  49.  
  50.     @Async
  51.     @Override
  52.     public void taskTest() {
  53.         System.out.println("我是beanName使用taskExecutor名字的线程：" + Thread.currentThread().getName());
  54.     }
  55. }
  56.  
  57. /**
  58.  *使用ThreadLocal存储共享的数据变量，如登录的用户信息
  59.  */
  60. public class UserUtils {
  61.     private static final ThreadLocal<String> userLocal = new ThreadLocal<>();
  62.  
  63.     public static String getUserId() {
  64.         return userLocal.get();
  65.     }
  66.  
  67.     public static void setUserId(String userId) {
  68.         userLocal.set(userId);
  69.     }
  70.  
  71.     public static void clear() {
  72.         userLocal.remove();
  73.     }
  74.  
  75. }

执行结果：

可以看到两种线程池都生效了，通过自定义配置可以让我们达到对@Async使用的掌控，以避免使用默认线程池带来的弊端。

但是也来了新的问题，在实际开发过程中我们需要父子线程之间传递一些数据，比如用户信息，分布式系统中用来链路追踪的tranceId等。通过上方的执行结果我们可以看到在子线程中是无法正常获取到父线程的线程数据的。

@Async实现父子线程之间的数据传递

多线程的情况下实现父子线程之间的数据传递方式有多种，这里我们介绍两种方式实现父子线程之间数据传递。

阿里巴巴TransmittableThreadLocal实现父子线程之间的用户数据传递

  1. public class UserUtils {
  2.     private static final ThreadLocal<String> userLocal = new TransmittableThreadLocal<>();
  3.  
  4.     public static String getUserId() {
  5.         return userLocal.get();
  6.     }
  7.  
  8.     public static void setUserId(String userId) {
  9.         userLocal.set(userId);
  10.     }
  11.  
  12.     public static void clear() {
  13.         userLocal.remove();
  14.     }
  15.  
  16. }

MDC实现线程池tranceId全链路传递

1：首先定义一个自定义线程池类继承ThreadPoolTaskExecutor

  1. // 首先定义一个自定义线程池类继承ThreadPoolTaskExecutor
  2. public class ThreadPoolExecutorMdcWrapper extends ThreadPoolTaskExecutor {
  3.  
  4.     @Override
  5.     public void execute(Runnable task) {
  6.         super.execute(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
  7.     }
  8.  
  9.     @Override
  10.     public <T> Future<T> submit(Callable<T> task) {
  11.         return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
  12.     }
  13.  
  14.     @Override
  15.     public Future<?> submit(Runnable task) {
  16.         return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
  17.     }
  18. }

2：编写tranceid包装工具类，判断当前线程对应MDC的上下文是否存在，存在则是子线程，设置MDC中的traceId值，不存在则生成新的tranceid，再执行run方法，执行结束之后清除线程tranceId

  1. // 编写tranceid包装工具类
  2. // 判断当前线程对应MDC的上下文是否存在，存在则是子线程，设置MDC中的traceId值
  3. // 不存在则生成新的tranceid，再执行run方法，执行结束之后清除线程tranceId
  4. public class ThreadMdcUtil {
  5.     private final static String MDC_TRACE_ID = "traceId";
  6.  
  7.     public static void setTraceIdIfAbsent() {
  8.         if (MDC.get(MDC_TRACE_ID) == null) {
  9.             MDC.put(MDC_TRACE_ID, UUID.randomUUID().toString().replaceAll("-", ""));
  10.         }
  11.     }
  12.  
  13.     public static <T> Callable<T> wrap(final Callable<T> callable, final Map<String, String> context) {
  14.         return () -> {
  15.             if (context == null) {
  16.                 MDC.clear();
  17.             } else {
  18.                 MDC.setContextMap(context);
  19.             }
  20.             setTraceIdIfAbsent();
  21.             try {
  22.                 return callable.call();
  23.             } finally {
  24.                 MDC.clear();
  25.             }
  26.         };
  27.     }
  28.  
  29.     public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {
  30.         return () -> {
  31.             if (context == null) {
  32.                 MDC.clear();
  33.             } else {
  34.                 MDC.setContextMap(context);
  35.             }
  36.             setTraceIdIfAbsent();
  37.             try {
  38.                 runnable.run();
  39.             } finally {
  40.                 MDC.clear();
  41.             }
  42.         };
  43.     }
  44. }

3：使用ThreadPoolExecutorMdcWrapper改造自定义线程池

  1.  
  2. // 初始化自定义线程池
  3. @Slf4j
  4. @Configuration
  5. @EnableConfigurationProperties({TaskExecutorProperties.class,ExportExecutorProperties.class})
  6. public class ExecutePoolConfig {
  7.  
  8.     // 普通任务线程池配置
  9.     private final TaskExecutorProperties taskExecutorProperties;
  10.  
  11.     // 导出任务线程池配置
  12.     private final ExportExecutorProperties exportExecutorProperties;
  13.  
  14.     @Autowired
  15.     public ExecutePoolConfig(TaskExecutorProperties taskExecutorProperties,ExportExecutorProperties exportExecutorProperties) {
  16.         this.taskExecutorProperties = taskExecutorProperties;
  17.         this.exportExecutorProperties = exportExecutorProperties;
  18.     }
  19.  
  20.     @Bean("taskExecutor")
  21.     public Executor taskExecutor() {
  22.         return buildExecutor(taskExecutorProperties);
  23.     }
  24.     @Bean("exportExecutor")
  25.     public Executor exportExecutor() {
  26.         return buildExecutor(exportExecutorProperties);
  27.     }
  28.  
  29.     /**
  30.      * 构建线程池
  31.      *
  32.      * @param executorProperties ExecutorBaseProperties
  33.      * @return {@link Executor}
  34.      */
  35.     private Executor buildExecutor(ExecutorBaseProperties executorProperties) {
  36.  
  37.         ThreadPoolExecutorMdcWrapper executor = new ThreadPoolExecutorMdcWrapper();
  38.  
  39.         // 设置核心线程数
  40.         executor.setCorePoolSize(executorProperties.getCorePoolSize());
  41.  
  42.         // 设置最大线程数
  43.         executor.setMaxPoolSize(executorProperties.getMaxPoolSize());
  44.  
  45.         // 设置队列大小
  46.         executor.setQueueCapacity(executorProperties.getQueueCapacity());
  47.  
  48.         // 设置线程池维护线程所允许的空闲时间
  49.         executor.setKeepAliveSeconds(executorProperties.getKeepAliveSeconds());
  50.  
  51.         // 设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean
  52.         executor.setWaitForTasksToCompleteOnShutdown(true);
  53.  
  54.         // 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁
  55.         executor.setAwaitTerminationSeconds(30);
  56.  
  57.         // 设置线程池中的线程的名称前缀
  58.         executor.setThreadNamePrefix(executorProperties.getThreadNamePrefix());
  59.  
  60.         // rejection-policy：当pool已经达到max size的时候，如何处理新任务
  61.         // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
  62.         RejectedExecutionHandler rejectedExecutionHandler = null;
  63.  
  64.         try {
  65.  
  66.             Class<?> clazz = Class
  67.                 .forName("java.util.concurrent.ThreadPoolExecutor$" + executorProperties.getRejectionPolicyName());
  68.             rejectedExecutionHandler = (RejectedExecutionHandler)clazz.newInstance();
  69.  
  70.         } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
  71.             log.error("获取rejection-policy异常，请查看配置文件", e);
  72.             return null;
  73.  
  74.         }
  75.  
  76.         executor.setRejectedExecutionHandler(rejectedExecutionHandler);
  77.         // 执行初始化
  78.         executor.initialize();
  79.         //return TtlExecutors.getTtlExecutor(executor);
  80.         return executor;
  81.     }
  82. }

4：执行结果

参考文章--MDC实现线程池tranceId全链路传递

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/102640?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号