当前位置：首页 > article >正文

Spring Boot 异步编程深入剖析

article 2025/3/3 19:16:07

Spring Boot 异步编程深入剖析

1. 异步方法的使用

原理深度解析

Spring Boot 的异步方法基于 Spring 的 AOP（面向切面编程）实现。当在方法上添加 @Async 注解时，Spring 会为该方法所在的类创建一个代理对象。当调用该异步方法时，实际上是调用代理对象的方法，代理对象会将该方法的执行委托给线程池中的一个线程去执行，而调用线程会继续执行后续代码，从而实现异步执行。

更复杂的使用场景

除了返回 CompletableFuture，还可以使用 ListenableFuture（在 Spring 4.0 之前）或无返回值的异步方法。

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.SettableListenableFuture;

import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {

    // 无返回值的异步方法
    @Async
    public void asyncVoidMethod() {
        try {
            Thread.sleep(2000);
            System.out.println("Async void method completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 使用 ListenableFuture
    @Async
    public ListenableFuture<String> asyncListenableMethod() {
        SettableListenableFuture<String> future = new SettableListenableFuture<>();
        try {
            Thread.sleep(2000);
            future.set("Async listenable method completed");
        } catch (InterruptedException e) {
            future.setException(e);
        }
        return future;
    }
}

踩坑记录

方法调用问题：如果在同一个类中调用自身的异步方法，@Async 注解不会生效。因为 Spring 的 AOP 代理是基于外部调用的，同一个类中的方法调用不会经过代理对象。解决方法是将异步方法提取到另一个服务类中。
异常处理问题：无返回值的异步方法中的异常不会被调用者捕获，因为调用者不会等待方法执行完成。可以在异步方法内部进行异常处理，或者使用 CompletableFuture 来捕获异常。

使用心得

对于一些耗时的 I/O 操作（如数据库查询、网络请求等），使用异步方法可以显著提高应用程序的响应性能。
合理使用 CompletableFuture 可以方便地处理异步任务的结果和异常，同时还可以进行任务的组合和链式调用。

2. 线程池配置

深入理解线程池参数

核心线程数（corePoolSize）：线程池保持的最小线程数。当有新任务提交时，如果线程池中的线程数小于核心线程数，会创建新的线程来执行任务。
最大线程数（maxPoolSize）：线程池允许的最大线程数。当队列已满且线程数小于最大线程数时，会创建新的线程来执行任务。
队列容量（queueCapacity）：用于存储等待执行的任务的队列的容量。当线程池中的线程数达到核心线程数时，新任务会被放入队列中等待执行。
线程空闲时间（keepAliveTime）：当线程池中的线程数超过核心线程数时，空闲线程在经过一定时间后会被销毁。

动态调整线程池参数

可以通过编写自定义的线程池管理器来动态调整线程池的参数。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
public class AsyncConfig implements AsyncConfigurer {

    private ThreadPoolTaskExecutor executor;

    @Override
    @Bean(name = "asyncExecutor")
    public Executor getAsyncExecutor() {
        executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("AsyncThread-");
        executor.initialize();
        return executor;
    }

    public void adjustCorePoolSize(int corePoolSize) {
        executor.setCorePoolSize(corePoolSize);
        executor.initialize();
    }
}

踩坑记录

队列容量设置不合理：如果队列容量设置过大，可能会导致大量任务堆积在队列中，从而影响系统的响应性能。如果队列容量设置过小，可能会导致线程池频繁创建新的线程，增加系统的开销。
线程池耗尽问题：如果任务提交速度过快，超过了线程池的处理能力，可能会导致线程池耗尽，从而抛出 RejectedExecutionException 异常。可以通过合理设置线程池参数和实现自定义的拒绝策略来解决这个问题。

使用心得

根据应用程序的实际情况合理设置线程池的参数，避免资源浪费和性能瓶颈。
定期监控线程池的状态，根据系统的负载情况动态调整线程池的参数。

3. 异步任务的监控与管理

高级监控方法

除了使用 CompletableFuture 来监控任务状态，还可以使用 Spring Boot Actuator 来监控线程池的状态。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

通过访问 /actuator/metrics 端点可以查看线程池的相关指标，如活跃线程数、任务完成数等。

任务链管理

可以使用 CompletableFuture 的 thenApply、thenAccept、thenCompose 等方法来构建任务链，实现复杂的异步任务管理。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @GetMapping("/asyncChain")
    public String asyncChain() {
        CompletableFuture<String> future1 = asyncService.asyncMethod();
        CompletableFuture<String> future2 = future1.thenApply(result -> result + " -> Next step");
        future2.thenAccept(finalResult -> System.out.println(finalResult));
        return "Async chain started";
    }
}

踩坑记录

任务链异常处理问题：在任务链中，如果某个任务抛出异常，后续的任务可能会受到影响。可以使用 exceptionally 方法来处理异常，确保任务链的稳定性。
内存泄漏问题：如果 CompletableFuture 没有正确处理，可能会导致内存泄漏。例如，如果一个 CompletableFuture 一直处于未完成状态，会占用内存资源。