SpringBoot的@Async注解有什么坑?

随笔6个月前发布 蝴蝶飞飞猫
56 0 0

前言

SpringBoot中,@Async注解可以实现异步线程调用,用法简单,体验舒适。
但是你一定碰到过异步调用不生效的情况,今天这篇文章总结了@Async注解的坑点,希望对你会有所帮助。

SpringBoot的@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); 
  } 
}

异常处理

异步方法中抛出的异常不能直接捕获,因为调用者将无法获取到异常。建议使用FutureCompletableFuture来捕获异步方法的异常并进行处理。

@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"; });

异步方法无返回结果

异步方法默认情况下是没有返回值的,如果需要获取异步方法的执行结果,依然要使用FutureCompletableFuture,可以将其设置为返回类型。

@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 发布!

© 版权声明

相关文章

暂无评论

您必须登录才能参与评论!
立即登录
暂无评论...