@Async 注解

旧城等待， 2024-03-26 12:33 54阅读 0赞

## 异步执行 ##

异步调用就是不用等待结果的返回就执行后面的逻辑；同步调用则需要等待结果再执行后面的逻辑。

通常我们使用异步操作时都会创建一个线程执行一段逻辑，然后把这个线程丢到[线程池][Link 1]中去执行，代码如下所示。

ExecutorService executorService = Executors.newFixedThreadPool(10);
    executorService.execute(() -> {
        
        try {
        
            // 业务逻辑
        } catch (Exception e) {
        
            e.printStackTrace();
        } finally {
        
        }
    });

这种方式尽管使用了 Java 的 Lambda，但看起来没那么优雅。在 Spring 中有一种更简单的方式来执行异步操作，只需要一个 **@Async** 注解即可，代码如下所示。

@Async
    public void saveLog() {
        
        System.err.println(Thread.currentThread().getName());
    }

我们可以直接在 Controller 中调用这个业务方法，它就是异步执行的，会在默认的线程池中去执行。需要注意的是，一定要在外部的类中去调用这个方法，如果在本类调用则不起作用，比如 this.saveLog()。最后在启动类上开启异步任务的执行，添加 **@EnableAsync** 即可。

另外，关于执行异步任务的线程池我们也可以自定义，首先我们定义一个线程池的配置类，用来配置一些参数，具体代码如下所示。

@Configuration
    @ConfigurationProperties(prefix = "spring.task.pool")
    public class TaskThreadPoolConfig {
        
        // 核心线程数
        private int corePoolSize = 5;
        // 最大线程数
        private int maxPoolSize = 50;
        // 线程池维护线程所允许的空闲时间
        private int keepAliveSeconds = 60;
        // 队列长度
        private int queueCapacity = 10000;
        // 线程名称前缀
        private String threadNamePrefix = "FSH-AsyncTask-";
        // get set ...
    }

然后我们重新定义线程池的配置，代码如下所示。

@Configuration
    public class AsyncTaskExecutePool implements AsyncConfigurer {
        
        private Logger logger = LoggerFactory.getLogger(AsyncTaskExecutePool.class);
        @Autowired
        private TaskThreadPoolConfig config;
        @Override
        public Executor getAsyncExecutor() {
        
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(config.getCorePoolSize());
            executor.setMaxPoolSize(config.getMaxPoolSize());
            executor.setQueueCapacity(config.getQueueCapacity());
            executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
            executor.setThreadNamePrefix(config.getThreadNamePrefix());
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            executor.initia lize();
            return executor;
        }
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        
            // 异步任务中异常处理
            return new AsyncUncaughtExceptionHandler() {
        
                @Override
                public void handleUncaughtException(Throwable arg0, Method arg1, Object... arg2) {
        
                    logger.error("==========================" + arg0.getMessage() + "=======================", arg0);
                    logger.error("exception method:" + arg1.getName());
                }
            };
        }
    }

配置完之后我们的异步任务执行的线程池就是我们自定义的了，我们可以在属性文件里面配置线程池的大小等信息，也可以使用默认的配置：

spring.task.pool.maxPoolSize=100

最后讲一下线程池配置的拒绝策略。当我们的线程数量高于线程池的处理速度时，任务会被缓存到本地的队列中。队列也是有大小的，如果超过了这个大小，就需要有拒绝的策略，不然就会出现内存溢出。目前支持两种拒绝策略：  
AbortPolicy：直接抛出 java.util.concurrent.RejectedExecutionException 异常。  
CallerRunsPolicy：主线程直接执行该任务，执行完之后尝试添加下一个任务到线程池中，这样可以有效降低向线程池内添加任务的速度。

建议大家用 CallerRunsPolicy 策略，因为当队列中的任务满了之后，如果直接抛异常，那么这个任务就会被丢弃。如果是 CallerRunsPolicy 策略，则会用主线程去执行，也就是同步执行，这样操作最起码任务不会被丢弃。

[Link 1]: https://so.csdn.net/so/search?q=%E7%BA%BF%E7%A8%8B%E6%B1%A0&spm=1001.2101.3001.7020