【Spring Boot】之@Async异步方法大坑引发线上事故

本文链接：https://blog.youkuaiyun.com/weixin_43840144/article/details/144698779

引言

常见项目开发搭建，经常用到多线程异步处理，其中使用最多的一种方式就是@Async注解
@Async注解是Spring为提供的关键工具，它可以标记在一个方法上，使得该方法在调用时在单独的线程中执行


@EnableAsync
@SpringBootApplication
public class Application {
   
   public static void main(String[] args) {
   		SpringApplication.run(Application.class, args);
   }
   
}

@Service
public class AsyncService {
    @Async
    public void asyncMethod() {
        // 异步任务逻辑
    }
}

事故

生产环境大量的定时任务异步处理，运行10日后，任务丢失，日志找不到执行痕迹

原因

在高并发或任务量较大的情况下。@Async 的默认线程池是 SimpleAsyncTaskExecutor，线程不复用、无限创建，极易造成资源耗尽。

总结

不要默认配置尤其是在高并发或任务量较大的情况下。@Async 的默认线程池是 SimpleAsyncTaskExecutor，换成 ThreadPoolTaskExecutor，按需控制线程池大小，避免资源占用过多。
异步任务的合理控制
不是所有任务都适合 @Async，尤其是那些可能会占用大量资源、长时间运行的任务。在实际场景中，应考虑任务的优先级、执行时间，甚至可以为不同任务分配不同的线程池。
监控与预警
使用异步任务时，要有完善的监控和预警。我们可以通过日志、监控工具来查看异步任务的执行情况，一旦任务堆积或线程池耗尽，及时调整配置或限流。

整改

实现接口AsyncConfigurer

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Slf4j
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Bean(name = "taskexecutor")
    public ThreadPoolTaskExecutor executor() {
    
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池创建时候初始化的线程数
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        // 最大线程数：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(100);
        // 缓冲队列：用来缓冲执行任务的队列
        executor.setQueueCapacity(100);
        // 允许线程的空闲时间*秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix("myasync-");
        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 设置线程池关闭的时候需要等待所有任务都完成 才能销毁其他的Bean
    	executor.setWaitForTasksToCompleteOnShutdown(true);
    	// 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
    	executor.setAwaitTerminationSeconds(120);
        // 初始化线程池
        executor.initialize();
        return executor;
    }

	@Override
    public Executor getAsyncExecutor() {
        return executor();
    }

    // 可选：自定义未捕获异常处理器
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) -> log.error("线程池执行热任务发送未知错误，执行方法：{}", method.getName(), ex); 
    }

}

继承AsyncConfigurerSupport
继承AsyncConfigurerSupport类是一种简便的方式，它提供了默认的实现，你只需覆盖你想要自定义的部分。这种方式减少了需要重写的方法数量，代码更加简洁

@Slf4j
@Configuration
@EnableAsync
public class AsyncConfig extends AsyncConfigurerSupport {

    @Bean(name = "taskexecutor")
    public ThreadPoolTaskExecutor executor() {
    
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池创建时候初始化的线程数
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        // 最大线程数：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(100);
        // 缓冲队列：用来缓冲执行任务的队列
        executor.setQueueCapacity(100);
        // 允许线程的空闲时间*秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix("myasync-");
        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 设置线程池关闭的时候需要等待所有任务都完成 才能销毁其他的Bean
    	executor.setWaitForTasksToCompleteOnShutdown(true);
    	// 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
    	executor.setAwaitTerminationSeconds(120);
        // 初始化线程池
        executor.initialize();
        return executor;
    }

	@Override
    public Executor getAsyncExecutor() {
        return executor();
    }

    // 可选：自定义未捕获异常处理器
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) -> log.error("线程池执行热任务发送未知错误，执行方法：{}", method.getName(), ex); 
    }

}

-配置自定义的TaskExecutor
自定义的线程池（代替默认线程池）；
设置多个线程池，在异步调用时，指明需要调用的线程池名称，如@Async(“taskexecutor2”)

@EnableAsync
@Configuration
public class TaskPoolConfig {
 
 	 //替换默认线程池
     @Bean(name = AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME)
     public Executor taskExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池创建时候初始化的线程数
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        // 最大线程数：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(100);
        // 缓冲队列：用来缓冲执行任务的队列
        executor.setQueueCapacity(100);
        // 允许线程的空闲时间*秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix("myasync-");
        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 设置线程池关闭的时候需要等待所有任务都完成 才能销毁其他的Bean
    	executor.setWaitForTasksToCompleteOnShutdown(true);
    	// 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
    	executor.setAwaitTerminationSeconds(120);
        // 初始化线程池
        executor.initialize();
        return executor;
     }
     
    @Bean(name = "taskexecutor2")
    public Executor taskExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池创建时候初始化的线程数
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        // 最大线程数：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(100);
        // 缓冲队列：用来缓冲执行任务的队列
        executor.setQueueCapacity(100);
        // 允许线程的空闲时间*秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix("myasync-");
        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 设置线程池关闭的时候需要等待所有任务都完成 才能销毁其他的Bean
    	executor.setWaitForTasksToCompleteOnShutdown(true);
    	// 设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
    	executor.setAwaitTerminationSeconds(120);
        // 初始化线程池
        executor.initialize();
        return executor;
    }
    
}