深入SpringBoot：Async注解的注意点

Felix...

于 2024-11-07 16:13:03 发布

阅读量944

点赞数 10

CC 4.0 BY-SA版权

分类专栏： # SpringBoot 文章标签： spring boot 后端 java

本文链接：https://blog.youkuaiyun.com/qq_47183158/article/details/143597570

SpringBoot 专栏收录该内容

24 篇文章

订阅专栏

Async注解的八大注意点

Spring Boot是一个流行的Java开发框架，提供了丰富的功能和便捷的配置，使得开发者可以更专注于业务逻辑。在异步编程方面，Spring Boot提供了@Async注解，它能够让方法异步执行，提高系统的并发性能。然而，在使用@Async注解时，有一些潜在的坑需要注意。本文将深入探讨Spring Boot中使用@Async注解时要注意的点，并提供相应的解决方案。

1. 缺少@EnableAsync注解

在使用@Async注解之前，必须在Spring Boot应用程序的主配置类上添加@EnableAsync注解，以启用异步方法的支持。如果忽略了这一步，@Async注解将不会生效。

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

2. 异步方法需独立

被@Async注解修饰的方法不能直接被同一个类中的其他方法调用。因为Spring会在运行时生成一个代理类，调用异步方法时实际上是调用这个代理类的方法。因此，如果在同一个类中直接调用异步方法，@Async注解将不会生效。

    @Service
    public class YourService {
        @Async
        public void asyncMethod() {
            // 异步执行的逻辑
        }

        public void callingAsyncMethod() {
            // 直接调用asyncMethod将无法异步执行
            asyncMethod();
        }
    }

解决方案是通过注入YourService的代理对象来调用异步方法。

    @Service
    public class YourService {
        @Autowired
        private YourService self;

        @Async
        public void asyncMethod() {
            // 异步执行的逻辑
        }

        public void callingAsyncMethod() {
            // 通过代理对象调用异步方法
            self.asyncMethod();
        }
    }

3. 不同的异步方法间无法相互调用

在同一个类中，一个异步方法调用另一个异步方法，也会出现不会异步执行的问题。这是由于Spring默认使用基于代理的AOP来实现异步方法，代理对象内部的方法调用不会触发AOP拦截。

    @Service
    public class YourService {
        @Async
        public void asyncMethod1() {
            // 异步执行的逻辑
        }

        @Async
        public void asyncMethod2() {
            // 异步执行的逻辑
            asyncMethod1(); // 这里调用将不会异步执行
        }
    }

解决方案是通过AopContext.currentProxy()获取当前代理对象，再调用异步方法。

    @Service
    public class YourService {
        @Autowired
        private YourService self;

        @Async
        public void asyncMethod1() {
            // 异步执行的逻辑
        }

        @Async
        public void asyncMethod2() {
            // 异步执行的逻辑
            self.asyncMethod1(); // 通过代理对象调用将异步执行
        }
    }

4. 返回值为void的异步方法无法捕获异常

如果使用@Async注解的异步方法的返回值为void，那么这个方法中抛出的异常将无法被捕获。这是因为在异步方法的调用线程和实际执行异步方法的线程之间无法传递异常。

    @Service
    public class YourService {
        @Async
        public void asyncMethod() {
            // 异步执行的逻辑
            throw new RuntimeException("Async method exception");
        }
    }

解决方案是将返回值设置为Future，这样就可以在调用get()方法时捕获到异常。

    @Service
    public class YourService {
        @Async
        public Future<Void> asyncMethod() {
            // 异步执行的逻辑
            throw new RuntimeException("Async method exception");
        }
    }

在调用异步方法时，可以通过Future的get()方法捕获到异常。

    @Service
    public class YourService {
        @Autowired
        private YourService self;

        public void callAsyncMethod() {
            try {
                self.asyncMethod().get();
            } catch (Exception e) {
                // 捕获异常
            }
        }
    }

5. 外部无法直接调用带有@Async注解的方法

如果在同一个类中直接调用带有@Async注解的方法，是无法异步执行的。因为Spring会在运行时生成一个代理类，外部直接调用实际上是调用的原始类的方法，而不是代理类的方法。

    @Service
    public class YourService {
        @Async
        public void asyncMethod() {
            // 异步执行的逻辑
        }
    }

    @Service
    public class AnotherService {
        @Autowired
        private YourService yourService;

        public void callAsyncMethod() {
            // 外部直接调用asyncMethod将无法异步执行
            yourService.asyncMethod();
        }
    }

解决方案是通过注入YourService的代理对象来调用异步方法。

    @Service
    public class YourService {
        @Autowired
        private YourService self;

        @Async
        public void asyncMethod() {
            // 异步执行的逻辑
        }
    }

    @Service
    public class AnotherService {
        @Autowired
        private YourService self;

        public void callAsyncMethod() {
            // 通过代理对象调用异步方法
            self.asyncMethod();
        }
    }

6. @Async方法不适用于private方法

@Async注解只对公有方法有效，因此`private

方法无法异步执行。如果尝试给一个private方法添加@Async`注解，将不会产生任何效果。

    @Service
    public class YourService {
        @Async
        private void asyncMethod() {
            // 这里的@Async注解将不会生效
        }
    }

解决方案是将要异步执行的逻辑抽取到一个公有方法中，并在私有方法中调用这个公有方法。

    @Service
    public class YourService {
        @Async
        public void asyncMethod() {
            doAsyncMethod();
        }

        private void doAsyncMethod() {
            // 异步执行的逻辑
        }
    }

7. 缺失异步线程池配置

在使用@Async注解时，Spring Boot默认会创建一个线程池来执行异步方法。如果没有进行配置，默认使用的是SimpleAsyncTaskExecutor，这是一个单线程的执行器，可能会导致性能瓶颈。

为了解决这个问题，可以配置一个合适的线程池。以下是一个示例的配置：

    @Configuration
    @EnableAsync
    public class AsyncConfig extends AsyncConfigurerSupport {
        @Override
        public Executor getAsyncExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(5);
            executor.setMaxPoolSize(10);
            executor.setQueueCapacity(25);
            executor.setThreadNamePrefix("Async-");
            executor.initialize();
            return executor;
        }
    }

这个配置使用了ThreadPoolTaskExecutor，并设置了核心线程数、最大线程数、队列容量等参数，根据实际情况进行调整。

8. 异步方法与事务的兼容

在默认情况下，使用@Async注解的方法与事务是不兼容的。因为在使用事务的方法中调用使用@Async注解的方法时，事务将无法传播到异步方法中，异步方法将在没有事务的情况下执行。

解决方案是将@Async注解添加到另外一个类的方法上，通过代理对象来调用异步方法。

    @Service
    public class YourService {
        @Autowired
        private AsyncService asyncService;

        @Transactional
        public void transactionalMethod() {
            // 在事务中调用异步方法
            asyncService.asyncMethod();
        }
    }

    @Service
    public class AsyncService {
        @Async
        public void asyncMethod() {
            // 异步执行的逻辑
        }
    }