Async注解失效几种场景

在现代的软件开发实践中，异步编程已经成为提升系统性能和响应速度的重要手段。Spring框架通过?@Async?注解提供了一种简便的异步执行机制。但是，不正确的使用可能会导致?@Async?注解失效，本文将深入剖析这些场景，并提供详细的解决方案。

场景一：私有方法调用

问题描述

在Spring中，@Async?注解不能应用于私有方法。因为Spring是通过代理机制来实现异步调用的，私有方法无法被代理拦截。

@Service
public class MyService {
    // 这是一个错误的示例，因为Spring无法代理私有方法
    @Async
    private void doSomething() {
        // 异步执行的代码
    }
}

解决方案

将需要异步执行的方法定义为公共方法（public），这样Spring的代理机制才能正确地处理它。

@Service
public class MyService {
    // 正确的做法是将方法定义为public
    @Async
    public void doSomething() {
        // 异步执行的代码
    }
}

场景二：同类方法内调用

问题描述

当你在同一个类的内部调用一个?@Async?注解的方法时，这个调用不会异步执行。这是因为代理是基于外部方法调用机制工作的。

@Service
public class MyService {
    public void myMethod() {
        // 这个调用不会异步执行，因为它是内部调用
        this.asyncMethod();
    }

    @Async
    public void asyncMethod() {
        // 异步执行的代码
    }
}

解决方案

有两种主要的解决方案：

1. 自我注入（Self-injection）：Spring 允许你将当前类注入到自己的实例中，这样可以通过代理来调用异步方法。

@Service
public class MyService {

    @Autowired
    private MyService self;

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

    @Async
    public void asyncMethod() {
        // 异步执行的代码
    }
}

1. 拆分服务（Service splitting）：将异步方法移动到另一个Spring管理的bean中。

@Service
public class MyAsyncService {
    @Async
    public void asyncMethod() {
        // 异步执行的代码
    }
}

@Service
public class MyService {

    @Autowired
    private MyAsyncService myAsyncService;

    public void myMethod() {
        // 调用另一个bean中的异步方法
        myAsyncService.asyncMethod();
    }
}

场景三：没有启用异步支持

问题描述

在Spring Boot应用中，仅仅在方法上添加?@Async?注解是不够的。你还需要在配置类上添加?@EnableAsync?注解来启用异步支持。

解决方案

在你的配置类或者启动类上添加?@EnableAsync?注解。

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

场景四：返回类型不正确

问题描述

如果你希望从异步方法中获取返回值，这个方法必须返回?Future?或其子类。否则，你将无法获取异步调用的结果。

@Service
public class MyService {
    // 错误示例：异步方法应该返回Future或其子类
    @Async
    public String doSomething() {
        // 异步执行的代码
        return "Done";
    }
}

解决方案

使用?Future，CompletableFuture?或?ListenableFuture?作为返回类型，并相应地处理返回值。

@Service
public class MyService {
    // 正确示例：返回CompletableFuture
    @Async
    public CompletableFuture<String> doSomething() {
        // 异步执行的代码
        return CompletableFuture.completedFuture("Done");
    }
}

场景五：异常处理不当

问题描述

异步方法中抛出的异常默认情况下是不会被调用者捕获的，因为它们是在不同的线程中执行的。

@Service
public class MyService {
    // 错误示例：异常不会被调用者捕获
    @Async
    public void doSomething() throws InterruptedException {
        throw new InterruptedException("Error occurred");
    }
}

解决方案

使用?CompletableFuture?的异常处理机制，或者其他异步结果处理框架提供的异常处理方法。

@Service
public class MyService {
    // 正确示例：使用CompletableFuture处理异常
    @Async
    public CompletableFuture<Void> doSomething() {
        return CompletableFuture.runAsync(() -> {
            throw new RuntimeException("Error occurred");
        }).exceptionally(ex -> {
            // 异常处理逻辑
            return null;
        });
    }
}

场景六：线程池配置不当

问题描述

默认情况下，Spring使用一个简单的线程池来执行异步任务。在高负载情况下，这可能会导致性能问题。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        // 错误示例：使用单线程执行器可能导致资源不足
        return Executors.newSingleThreadExecutor();
    }
}

解决方案

自定义线程池配置，使用?ThreadPoolTaskExecutor?提供更好的性能和更多的配置选项。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }
}

场景七：事务管理冲突

问题描述

@Transactional?注解通常与?@Async?注解冲突，因为事务通常绑定到一个线程，而异步方法在不同的线程中执行。

@Service
public class MyService {
    // 错误示例：@Transactional和@Async的冲突
    @Async
    @Transactional
    public void doSomething() {
        // 异步执行的代码
    }
}

解决方案

确保事务管理和异步执行逻辑正确分离。通常，你需要在调用异步方法之前处理完所有事务相关的工作。

@Service
public class MyService {
    // 正确示例：分离事务管理和异步执行的逻辑
    @Transactional
    public void doTransactionalWork() {
        // 事务相关的工作
    }

    @Async
    public void doAsyncWork() {
        // 异步执行的代码
    }

    public void doWork() {
        doTransactionalWork();
        doAsyncWork();
    }
}

场景八：同步调用阻塞

问题描述

如果你在调用异步方法后立即调用?get()?方法来获取结果，这会阻塞当前线程，直到异步操作完成。

@Service
public class MyService {
    // 错误示例：同步阻塞
    @Async
    public CompletableFuture<String> doSomething() {
        // 异步执行的代码
        return CompletableFuture.completedFuture("Done");
    }
    
    public void anotherMethod() {
        CompletableFuture<String> future = doSomething();
        String result = future.get(); // 这里会阻塞
    }
}

解决方案

使用?CompletableFuture?的回调函数，例如?thenAccept()?或?thenApply()，来处理异步操作的结果。

@Service
public class MyService {
    // 正确示例：使用回调函数处理结果
    @Async
    public CompletableFuture<String> doSomething() {
        // 异步执行的代码
        return CompletableFuture.completedFuture("Done");
    }
    
    public void anotherMethod() {
        CompletableFuture<String> future = doSomething();
        future.thenAccept(result -> {
            // 处理结果，不会阻塞当前线程
        });
    }
}

场景九：安全上下文丢失

问题描述

在异步执行过程中，Spring Security 的安全上下文可能不会自动传递到执行方法的线程。

@Service
public class MyService {
    // 错误示例：安全上下文可能会丢失
    @Async
    public void doSomething() {
        // 异步执行代码，需要安全上下文
    }
}

解决方案

使用?DelegatingSecurityContextRunnable?或?DelegatingSecurityContextExecutor?来传递安全上下文。

@Service
public class MyService {
    // 正确示例：使用DelegatingSecurityContextRunnable来传递安全上下文
    @Async
    public void doSomething() {
        SecurityContext context = SecurityContextHolder.getContext();
        Runnable task = new DelegatingSecurityContextRunnable(() -> {
            // 异步执行代码，现在有了安全上下文
        }, context);
        new Thread(task).start();
    }
}

总结

正确地使用?@Async?注解可以帮助你的应用程序实现高效的异步执行，但它也需要你注意以上提到的陷阱。确保你的方法公开、配置正确、异常处理得当、线程池适当、事务管理分离、避免同步阻塞和传递安全上下文，这些都是确保?@Async?正常工作的关键。

👉 💐🌸 公众号请关注 "果酱桑", 一起学习,一起进步! 🌸💐