前言
SpringBoot中，@Async注解可以实现异步线程调用，用法简单，体验舒适。
但是你一定碰到过异步调用不生效的情况，今天这篇文章总结了@Async注解的坑点，希望对你会有所帮助。
未启用异步支持
Spring Boot默认情况下不启用异步支持，确保在主配置类上添加@EnableAsync注解以启用异步功能。
@SpringBootApplication
@EnableAsync
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
没有配置线程池
如果没有显式地配置线程池，Spring Boot将使用默认的SimpleAsyncTaskExecutor实现。
在生产环境，可能导致性能问题。建议使用自定义的线程池配置，推荐ThreadPoolTaskExecutor。
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10); // 设置核心线程数
executor.setMaxPoolSize(100); // 设置最大线程数
executor.setQueueCapacity(10); // 设置队列容量
executor.setThreadNamePrefix("Async-");
// 设置线程名前缀 executor.initialize();
return executor;
}
// 其他配置方法...
}
异步方法在同一个类调用
我们知道Spring通过@Async注解实现异步的功能，底层其实是通过Spring的AOP实现的，也就是说它需要通过JDK动态代理或者cglib，生成代理对象。
可以尝试将异步方法移到另一个Bean中，然后通过依赖注入进行调用，这也是万金油用法。
// 你的业务服务 @Service
public class MyService {
@Autowired
private AsyncService asyncService;
@Async
public void asyncMethod() {
// 异步方法逻辑...
asyncService.asyncMethod();
// 在另一个Bean中调用异步方法
}
}
// 你声明的异步服务，这里面可以是你所有的异步方法，哪里调用直接注入即可。
@Service
public class AsyncService {
@Async
public void asyncMethod() {
// 异步方法逻辑...
}
}
方法非public
在实际工作中，我们使用频率最高的可能是public和private了。
如果在定义Service类中的某个方法时，有时把权限修饰符定义错了，例如：
@Slf4j
@Service
public class UserService {
@Async
private void async(String value) {
log.info("async:{}", value);
}
}
这个例子中将UserService类的async()方法的权限修饰符定义成了private的，这样@Async注解也会失效。
因为private修饰的方法，只能在UserService类的对象中使用。
而@Async注解的异步功能，需要使用Spring的AOP生成UserService类的代理对象，该代理对象没法访问UserService类的private方法，因此会出现@Async注解失效的问题。
事务失效问题
@Async方法默认不会继承父方法的事务。如果需要事务支持，请确保异步方法和调用该方法的方法都被@Transactional注解标记。
@Service
public class MyService {
@Autowired
private MyRepository myRepository;
@Async
@Transactional
public void asyncMethod() {
// 异步方法逻辑... myRepository.save(entity);
}
}
异常处理
异步方法中抛出的异常不能直接捕获，因为调用者将无法获取到异常。建议使用Future或CompletableFuture来捕获异步方法的异常并进行处理。
@Service
public class MyService {
@Async
public CompletableFuture<String> asyncMethod() {
try {
// 异步方法逻辑...
return CompletableFuture.completedFuture("Success");
} catch (Exception e) {
// 处理异常... return CompletableFuture.failedFuture(e);
}
}
// 调用异步方法并处理异常
CompletableFuture<String> future = myService.asyncMethod();
future.exceptionally(ex -> { // 异常处理逻辑... return "Error"; });
异步方法无返回结果
异步方法默认情况下是没有返回值的，如果需要获取异步方法的执行结果，依然要使用Future或CompletableFuture，可以将其设置为返回类型。
@Service
public class MyService {
@Async
public CompletableFuture<String> asyncMethod() {
// 异步方法逻辑...
return CompletableFuture.completedFuture("Result");
}
}
// 调用异步方法并获取结果
CompletableFuture<String> future = myService.asyncMethod();
String result = future.get();
// 阻塞等待结果
当然，正常情况下我们不需要返回结果，而且我也不建议这么干，异步线程本身也最适合处理不需要返回值的一类任务。
在实际项目中，如果想要使用@Async注解的异步功能，相关方法的返回值必须是void或者Future。
循环调用问题
当在同一个类中调用异步方法时，注意避免出现无限递归的循环调用。这可能会导致应用程序卡死或内存溢出。
@Service
public class MyService {
@Autowired
private MyService myService;
// 自身依赖
@Async
public void asyncMethod() {
// 异步方法逻辑...
myService.asyncMethod();
// 会导致无限递归调用
}
}
这个坑点一般人不会遇到，但如果某些业务场景是关于树形结构的遍历、图算法等等，还是有几率出现这种情况的，这个坑点列出来仅供学习和了解。
方法用static修饰了
我们的方法会使用static修饰，这样在调用的地方，可以直接使用类名.方法名，访问该方法了。
但如果在@Async方法上加了static修饰符，例如：
@Slf4j
@Service
public class UserService {
@Async
public static void async(String value) {
log.info("async:{}", value);
}
}
这时@Async的异步功能会失效，因为这种情况idea会直接报错：Methods annotated with '@Async' must be overridable 。
使用@Async注解声明的方法，必须是能被重写的，很显然static修饰的方法，是类的静态方法，是不允许被重写的。
因此这种情况下，@Async注解的异步功能会失效。
方法用final修饰
用final修饰的类，没法被继承。
用final修饰的方法，没法被重写。
用final修饰的变量，没法被修改。
如果final使用不当，也会导致@Async注解的异步功能失效，例如：
@Slf4j
@Service
public class UserService {
public void test() {
async("test");
}
@Async
public final void async(String value) {
log.info("async:{}", value);
}
}
这种情况下idea也会直接报错：Methods annotated with '@Async' must be overridable 。
因为使用final关键字修饰的方法，是没法被子类重写的。
因此这种情况下，@Async注解的异步功能会失效。
异步方法顺序问题
异步方法的执行是非阻塞的，它们可能以任意顺序完成。如果需要按照特定的顺序处理结果，可以使用CompletableFuture的thenApply方法或者使用@Async的order属性来指定顺序。
@Service
public class MyService {
@Async("threadPoolTaskExecutor")
public CompletableFuture<String> asyncMethod1() {
// 异步方法1逻辑...
return CompletableFuture.completedFuture("Result1");
}
@Async("threadPoolTaskExecutor")
public CompletableFuture<String> asyncMethod2() {
// 异步方法2逻辑...
return CompletableFuture.completedFuture("Result2");
}
}
// 调用异步方法并处理结果顺序
CompletableFuture<String> future1 = myService.asyncMethod1();
CompletableFuture<String> future2 = future1.thenCompose( result1 -> myService.asyncMethod2());
String finalResult = future2.get();
// 阻塞等待最终结果
自己new的对象
在项目中，我们经常需要new一个对象，然后对他赋值，或者调用它的方法。
但如果new了一个Service类的对象，可能会出现一些意想不到的问题，例如：
@Slf4j
@Service
public class UserService {
@Async
public void async(String value) {
log.info("async:{}", value);
}
}
@Service
public class TestService {
public void test() {
UserService userService = new UserService();
userService.async("test");
}
}
在TestService类的test()方法中，new了一个UserService类的对象，然后调用该对象的async()方法。
很显然这种情况下，async()方法只能同步执行，没法异步执行。
因为在项目中，我们自己new的对象，不会被Spring管理，因此也就无法使用Spring的异步功能。同样道理，如果没有被@ComponentScan注解指定项目中扫描的包路径，也会导致@Async注解异步的功能失效。
总结
这里面，我个人认为绝大多数人会遇到的坑点集中在没有配置自定义线程池、异步方法在同一个类中调用、事务不起作用这几个问题上，在实际使用时候要注意@Async注解失效的场景。
本文由博客一文多发平台 OpenWrite 发布！
