SpringBoot中@Async使用注意事项

前言

@Async这个注解想必大家都用过，是用来实现异步调用的。一个方法加上这个注解以后，当被调用时会使用新的线程来调用。但其实这里面也有一个坑。

问题

这个注解使用时存在如下问题：在没有自定义线程池的场景下，默认会采用SimpleAsyncTaskExecutor创建线程，线程池的最大大小为Integer的MAX_VALUE，相当于调用一次创建一个线程，缺乏线程重用机制。在并发大的场景下可能引发严重性能问题。下面是他的源代码：

/**
 * {@link TaskExecutor} implementation that fires up a new Thread for each task,
 * executing it asynchronously.
 *
 * <p>Supports limiting concurrent threads through the "concurrencyLimit"
 * bean property. By default, the number of concurrent threads is unlimited.
 *
 * <p><b>NOTE: This implementation does not reuse threads!</b> Consider a
 * thread-pooling TaskExecutor implementation instead, in particular for
 * executing a large number of short-lived tasks.
 */
public class SimpleAsyncTaskExecutor extends CustomizableThreadCreator
		implements AsyncListenableTaskExecutor, Serializable {
    //省略不重要的方法
    
	@Override
	public void execute(Runnable task, long startTimeout) {
		Assert.notNull(task, "Runnable must not be null");
		Runnable taskToUse = (this.taskDecorator != null ? this.taskDecorator.decorate(task) : task);
		if (isThrottleActive() && startTimeout > TIMEOUT_IMMEDIATE) {
			this.concurrencyThrottle.beforeAccess();
			doExecute(new ConcurrencyThrottlingRunnable(taskToUse));
		}
		else {
			doExecute(taskToUse);
		}
	}
    
    /**
	 * 模板方法，用于实际执行任务.
	 * <p>默认实现创建一个新线程并启动它
	 */
	protected void doExecute(Runnable task) {
        //如果threadFactory为空则直接创建线程执行。
		Thread thread = (this.threadFactory != null ? this.threadFactory.newThread(task) : createThread(task));
		thread.start();
	}
    
}

那么如何解决这个问题呢？可以采用下面的方法：

自定义线程池

有如下几种方式可以配置线程池，一种配置默认线程池，让所有@Async自动共享或者配置单独的线程池，使用@Async时指定线程池。

1. 使用配置文件中配置默认线程池

   1. application.properties参考配置，yml文件同理。

   2. # 线程池创建时的初始化线程数，默认为8
      spring.task.execution.pool.core-size=1
      # 线程池的最大线`在这里插入代码片`程数，默认为int最大值
      spring.task.execution.pool.max-size=1
      # 用来缓冲执行任务的队列，默认为int最大值
      spring.task.execution.pool.queue-capacity=10
      # 线程终止前允许保持空闲的时间
      spring.task.execution.pool.keep-alive=60s
      # 是否允许核心线程超时
      spring.task.execution.pool.allow-core-thread-timeout=true
      # 是否等待剩余任务完成后才关闭应用
      spring.task.execution.shutdown.await-termination=false
      # 等待剩余任务完成的最大时间
      spring.task.execution.shutdown.await-termination-period=
      # 线程名的前缀，设置好了之后可以方便我们在日志中查看处理任务所在的线程池
      spring.task.execution.thread-name-prefix=asynctask-
      

2. 通过实现接口配置默认线程池

   1. 实现AsyncConfigurer覆盖getAsyncExecutor()方法。注意：这个方法的优先级比配置文件高。

   2. @Configuration
      @EnableAsync
      public class AsyncConfig implements AsyncConfigurer {
          public Executor getAsyncExecutor() {
              ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
              executor.setCorePoolSize(3); //核心线程数
              executor.setMaxPoolSize(3);  //最大线程数
              executor.setQueueCapacity(1000); //队列大小
              executor.setKeepAliveSeconds(600); //线程最大空闲时间
              executor.setThreadNamePrefix("async-Executor-"); //指定用于新创建的线程名称的前缀。
              executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略（一共四种，此处省略）
              // 这一步千万不能忘了，否则报错： java.lang.IllegalStateException: ThreadPoolTaskExecutor not initialized
              executor.initialize();
              return executor;
          }
      }
      

3. 单独配置线程池，使用@Async指定线程池

   1. 这种方式可以给每个async的方法指定单独的线程池，但缺点是开发得知道怎么去设置。

   2. /**
      * 独立线程池配置
      */
      @Configuration
      public class TaskExecutorConfig {
          @Bean
          public TaskExecutor taskExecutor() {
              ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
              // 设置核心线程数
              executor.setCorePoolSize(1);
              // 设置最大线程数
              executor.setMaxPoolSize(1);
              // 设置队列容量
              executor.setQueueCapacity(20);
              // 设置线程活跃时间（秒）
              executor.setKeepAliveSeconds(60);
              // 设置默认线程名称
              executor.setThreadNamePrefix("task-");
              // 设置拒绝策略
              executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
              // 等待所有任务结束后再关闭线程池
              executor.setWaitForTasksToCompleteOnShutdown(true);
              return executor;
          }
      }
      
      public class AsyncService {
          @Async("taskExecutor")
          public void task1() throws InterruptedException {
              TimeUnit.SECONDS.sleep(1L);
              log.info("task1 complete");
          }
      
      
          @Async("taskExecutor")
          public void task2() throws InterruptedException {
              TimeUnit.SECONDS.sleep(2L);
              log.info("task2 complete");
          }
      
          @Async("taskExecutor")
          public void task3() throws InterruptedException {
              TimeUnit.SECONDS.sleep(3L);
              log.info("task3 complete");
          }
      }
      

   3. 下面是测试代码，大家可以用这个代码分别测试上述3种方式。

      @RestController
      @RequestMapping("/async")
      public class AsyncController {
          @Autowired
          AsyncService asyncService;
      
          @RequestMapping("/test")
          public String test() throws InterruptedException {
              asyncService.task1();
              asyncService.task2();
              asyncService.task3();
              return "success";
          }
      }
      
      @Service
      @Slf4j
      public class AsyncService {
          @Async
          public void task1() throws InterruptedException {
              TimeUnit.SECONDS.sleep(1L);
              log.info("task1 complete");
          }
      
          @Async
          public void task2() throws InterruptedException {
              TimeUnit.SECONDS.sleep(2L);
              log.info("task2 complete");
          }
      
          @Async
          public void task3() throws InterruptedException {
              TimeUnit.SECONDS.sleep(3L);
              log.info("task3 complete");
          }
      }