1. 需求背景
当我们需要提高系统的并发性能时，我们可以将耗时的操作异步执行，从而避免线程阻塞，提高系统的并发性能。例如，在处理大量的并发请求时，如果每个请求都是同步阻塞的方式处
理，系统的响应时间会变得很长。而使用异步编程，可以将一些耗时的操作交给其他线程去处理，从而释放主线程，提高系统的并发能力。
2. SpringBoot如何实现异步调用
从Spring 3开始，可以通过在方法上标注@Async注解来实现异步方法调用。这意味着当我们调用被@Async注解修饰的方法时，它会在后台以异步方式执行。为了启用异步功能，我们需要
一个配置类，并在该类上使用@EnableAsync注解。这个注解告诉Spring要开启异步功能。
3.?异步调用实现步骤
第一步：新建配置类，开启@Async功能支持
使用@EnableAsync来开启异步任务支持，@EnableAsync注解可以直接放在SpringBoot启动类上，也可以单独放在其他配置类上。这里选择使用单独的配置类SyncConfiguration。
使用@Async注解，在默认情况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池。
使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误，所以在使用Spring中的@Async异步
框架时要自定义线程池，替代默认的SimpleAsyncTaskExecutor，这也是自定义配置的意义之一。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | @Configuration
@EnableAsync
public?class?SyncConfiguration {
????@Bean(name =?"asyncPoolTaskExecutor")
????public?ThreadPoolTaskExecutor executor() {
????????ThreadPoolTaskExecutor taskExecutor =?new?ThreadPoolTaskExecutor();
????????//核心线程数，设置核心线程数。核心线程数是线程池中一直保持活动的线程数量，即使它们是空闲的。
????????taskExecutor.setCorePoolSize(10);
????????//设置线程池维护线程的最大数量。当缓冲队列已满并且核心线程数的线程都在忙碌时，线程池会创建新的线程，直到达到最大线程数。
????????taskExecutor.setMaxPoolSize(100);
????????//设置缓冲队列的容量。当所有的核心线程都在忙碌时，新的任务将会被放入缓冲队列中等待执行。
????????taskExecutor.setQueueCapacity(50);
????????//设置非核心线程的空闲时间。当超过核心线程数的线程在空闲时间达到设定值后，它们将被销毁，以减少资源的消耗。
????????taskExecutor.setKeepAliveSeconds(200);
????????//异步方法内部线程名称
????????taskExecutor.setThreadNamePrefix("async-");
????????/**
?????????* 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
?????????* 通常有以下四种策略：
?????????* ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
?????????* ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
?????????* ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
?????????* ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
?????????*/
????????taskExecutor.setRejectedExecutionHandler(new?ThreadPoolExecutor.CallerRunsPolicy());
????????taskExecutor.initialize();
????????return?taskExecutor;
????}
}
|
注：
Spring提供了多种线程池：
-
SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。
-
SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地
-
ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类
-
ThreadPoolTaskScheduler：可以使用cron表达式
-
ThreadPoolTaskExecutor?：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装
第二步：在方法上标记异步调用
在异步处理的方法上添加@Async注解，代表该方法为异步处理。
| 1 2 3 4 5 6 7 8 9 | public?class?AsyncTask {
????@Async
????public?void?Task() {
????????long?t1 = System.currentTimeMillis();
????????Thread.sleep(5000);
????????long?t2 = System.currentTimeMillis();
????????log.info("task cost {} ms"?, t2-t1);
????}
|
注：
在异步编程中，如果需要处理带有返回值的异步方法（有则继续浏览，无则跳过），Spring提供了java.util.concurrent.Future接口和java.util.concurrent.CompletableFuture类来处理异步任务的返回值。
1. 使用Future接口：Future接口表示一个异步计算的结果。我们可以通过调用Future对象的get()方法来获取异步任务的返回值，但这将阻塞当前线程，直到异步任务完成并返回结果
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | @Service
public?class?MyService {
????@Async
????public?Future<String> asyncMethodWithReturnValue() {
????????// 模拟耗时操作
????????try?{
????????????Thread.sleep(2000);
????????}?catch?(InterruptedException e) {
????????????e.printStackTrace();
????????}
?????????
????????return?new?AsyncResult<>("Async method result");
????}
}
|
上述示例中，asyncMethodWithReturnValue()方法使用@Async注解标记为异步方法，并返回一个Future<String>对象。在方法内部，我们使用AsyncResult类来创建一个包含异步结果的Future对象。
在调用该异步方法时，可以使用get()方法来获取异步任务的返回值。但需要注意，get()方法会阻塞当前线程，直到异步任务执行完成并返回结果。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | @Autowired
private?MyService myService;
public?void?someMethod() {
????Future<String> futureResult = myService.asyncMethodWithReturnValue();
?????
????// 阻塞等待异步任务完成并获取返回值
????try?{
????????String result = futureResult.get();
????????System.out.println("Async method result: "?+ result);
????}?catch?(InterruptedException | ExecutionException e) {
????????e.printStackTrace();
????}
}
|
上述示例中，我们通过调用futureResult.get()方法来获取异步任务的返回值。如果异步任务还未完成，调用get()方法将会阻塞当前线程，直到异步任务完成并返回结果。
2. 使用CompletableFuture类：CompletableFuture是Java 8引入的一个强大的异步编程工具，提供了更加灵活和功能丰富的异步任务处理方式。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | @Service
public?class?MyService {
????@Async
????public?CompletableFuture<String> asyncMethodWithReturnValue() {
????????// 模拟耗时操作
????????try?{
????????????Thread.sleep(2000);
????????}?catch?(InterruptedException e) {
????????????e.printStackTrace();
????????}
?????????
????????return?CompletableFuture.completedFuture("Async method result");
????}
}
|
在上述示例中，asyncMethodWithReturnValue()方法使用@Async注解标记为异步方法，并返回一个CompletableFuture<String>对象。在方法内部，我们使用CompletableFuture.completedFuture()方法创建一个包含异步结果的CompletableFuture对象。
在调用该异步方法时，可以链式调用thenApply()、thenAccept()等方法来对异步任务的结果进行处理。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | @Autowired
private?MyService myService;
public?void?someMethod() {
????CompletableFuture<String> futureResult = myService.asyncMethodWithReturnValue();
?????
????futureResult.thenAccept(result -> {
????????System.out.println("Async method result: "?+ result);
????});
?????
????// 执行其他操作
?????
????// 阻塞等待异步任务完成
????futureResult.join();
}
|
在上述示例中，我们通过调用thenAccept()方法来处理异步任务的结果，而不需要显式调用get()方法。thenAccept()方法接受一个Consumer函数式接口，用于处理异步任务的结果。
此外，CompletableFuture还提供了丰富的方法，例如thenApplyAsync()、thenCompose()、thenCombine()等，用于处理复杂的异步任务流程。
注：
当使用CompletableFuture处理异步任务时，以下是thenApplyAsync()、thenCompose()、thenCombine()和thenAccept()这四个方法的区别
thenApplyAsync()和thenAccept()用于处理异步任务的结果，并返回一个新的CompletableFuture或不返回任何结果。thenCompose()用于处理异步任务的结果，并返回一个新的CompletableFuture，该结果是另一个CompletionStage的结果。thenCombine()用于组合两个异步任务的结果，并应用指定的函数处理结果，并返回一个新的CompletableFuture。
第三步：在需要进行异步执行的地方进行调用
4. @Async的原理
-
当一个带有@Async注解的方法被调用时，Spring会创建一个异步代理对象来代理这个方法的调用。
-
异步代理对象会将方法调用封装为一个独立的任务，并将该任务提交给异步任务执行器。
-
异步任务执行器从线程池中获取一个空闲的线程，并将任务分配给该线程执行。
-
调用线程立即返回，不会等待异步任务的执行完成。
-
异步任务在独立的线程中执行，直到任务完成。
-
异步任务执行完成后，可以选择返回结果或者不返回任何结果。