@Async 不生效还丢登录态,后端先查这4处
排查一个导出功能时遇到两个怪事:接口 200 毫秒就返回了,日志里却一条记录都没有;另一个服务更离谱,方法明明标了
@Async,写进库的create_by全是 null。两件事看着不相关,根子是同一个——你以为 Spring 帮你开了个线程,其实它只是给 Bean 套了个代理。代理没走到、线程换了人、上下文没跟过去,问题就全出来了。下面按排查顺序,把这四个地方挨个拆开。
一、@Async 不生效的 4 种典型现象
@Async 的作用只有一个:把方法调用从当前线程挪到另一个线程执行,调用方立刻拿到返回值走人。它不创建线程池,不改变业务逻辑,也不负责异常处理。
真正让人头疼的是它失效的方式特别安静。不报错,不警告,代码看起来完全正常。
现象一:断点打进去,发现还在原来的线程。 方法上标了 @Async,调用方也正常返回,但日志里的线程名还是 http-nio-8080-exec-1。这说明方法压根没异步,同步跑完了才返回。最常见的原因是同类内部调用,后面细说。
现象二:异步是异步了,登录用户没了。 主线程里 UserContext.get() 有值,异步方法里返回 null。MDC 里的 traceId 也断了,一条链路在日志系统里碎成两段。
现象三:返回值永远是 null。 方法声明 String,异步执行完也确实算出了结果,但调用方拿到的就是 null,一点脾气没有。
现象四:线程池参数改了没反应。 你把 maxPoolSize 调到 50,压测时线程数死活停在 8。这不是配置没生效,是队列没设上限,池子根本没机会扩容。
这四种现象对应四个不同的机制问题,混在一起排查只会越查越乱。分开看,每个都能一两句话讲清楚。
下面这张表是速查版,先对号入座再往下读:
| 现象 | 直接原因 | 去哪一节看 |
|---|---|---|
| 还在原线程执行 | 同类自调用,没经过代理 | 二、三节 |
| 用户信息、traceId 丢失 | ThreadLocal 不跨线程 | 二、三节 |
| 返回值是 null | 返回类型不是 void/Future | 四节 |
| 线程数上不去 | 队列无界,扩容条件不成立 | 二、四节 |
二、@Async 为什么失效:代理、线程池、ThreadLocal 三件事
@Async 能生效的唯一前提是:调用必须经过 Spring 生成的代理对象。这是理解所有失效场景的第一把钥匙。
2.1 异步是靠代理“劫持”调用实现的
Spring 启动时会扫描所有 Bean,发现方法或类上有 @Async,就给这个 Bean 生成一个代理。代理里包了一层拦截器,逻辑很直白:
调用方 -> 代理对象 -> 拦到 @Async -> 把方法包装成任务丢进线程池 -> 立刻返回
|
+-> 线程池里的线程真正执行方法体
关键点在于:调用方手里拿到的必须是代理,不是原始对象。你从容器里 @Autowired 注入的、@Resource 拿到的,都是代理。所以跨 Bean 调用没问题。
同一类里 this.xxx() 调用就绕过了代理。this 是原始对象自己,方法体直接执行,拦截器连影子都没有。这不是 Spring 的 bug,任何基于代理的 AOP 都这样,@Transactional、@Cacheable 全部同一个毛病。
还有一个容易忽略的边界:private 方法和 final 方法也拦不住。CGLIB 靠继承生成子类,私有方法不参与继承,final 方法不允许覆盖。标了也没用。
2.2 Spring 找线程池有一个固定顺序
@Async 自己不创建线程池,它得问容器要一个。查找顺序是这样的:
- 容器里有
AsyncConfigurer类型的 Bean,就用它getAsyncExecutor()返回的。 - 没有的话,找容器里
TaskExecutor类型的 Bean。 - 还没有,找名字叫
taskExecutor的 Bean。 - 实在找不到,兜底
SimpleAsyncTaskExecutor——每次调用新建一个线程,不池化,不限制数量。
Spring Boot 在这条链上插了一脚。它默认会创建一个名字叫 applicationTaskExecutor 的线程池,并且注册一个内置的 AsyncConfigurer 指向它。所以正常项目里,@Async 用的就是这个自动配置的池。
这个池的默认参数值得记一下,因为很多“参数改了没反应”的疑惑都来自这里:
| 参数 | 默认值 | 后果 |
|---|---|---|
| corePoolSize | 8 | 平时最多 8 个线程干活 |
| maxPoolSize | Integer.MAX_VALUE | 纸面上能无限扩 |
| queueCapacity | Integer.MAX_VALUE | 队列永远不满,所以永远不会扩 |
| keepAlive | 60 秒 | 空闲线程一分钟后回收 |
ThreadPoolTaskExecutor 的扩容条件写得很明确:核心线程占满 并且 队列也满了,才创建新线程。队列容量是 Integer.MAX_VALUE,等于告诉它“别扩了,排队就行”。所以 maxPoolSize 那个最大值,在生产上几乎从来没被触发过。
代价是队列会一直吃内存。任务堆到几十万个,每个任务还抓着请求参数和对象引用,OOM 只是时间问题。这个默认值属于“能用但别信”的级别。
2.3 ThreadLocal 是“线程自己的抽屉”
ThreadLocal 的存储结构可以想成一排带锁的抽屉,每个线程只认自己那把钥匙。你在线程 A 里 set 的值,线程 B 打开抽屉看到的是空的。
Thread A 的抽屉: { userContext = "10086", traceId = "a1b2" }
Thread B 的抽屉: { } <- 刚被线程池创建,空的
Spring Security 的 SecurityContextHolder 默认就是 ThreadLocal 实现,MDC 底层也是 ThreadLocal,很多团队自己写的 UserContext、TenantContext 同样是。异步把任务交给线程 B,B 的抽屉自然是空的。
这事还有个更阴的变种:线程池的线程是复用的。如果上一次任务往抽屉里塞了东西没清理,下一个任务打开抽屉会看到上一个人的数据。日志串号、数据串租户,排查起来能耗一整天。
解决办法不是“别用 ThreadLocal”,而是在线程切换的那一刻,把抽屉里的东西抄一份带过去,用完再恢复原样。Spring 为这个场景留了接口:TaskDecorator。
三、实战:一个能跑起来的完整 demo
这一节给出一个完整工程,用 5 个接口把“自调用失效”“上下文丢失”“返回值陷阱”“线程池参数”四件事全演示一遍。代码可以直接复制运行。
3.1 项目结构
async-demo
├── pom.xml
└── src/main
├── java/com/example/asyncdemo
│ ├── AsyncDemoApplication.java
│ ├── config/AsyncConfig.java
│ ├── context/UserContext.java
│ ├── context/UserContextFilter.java
│ ├── service/AuditService.java
│ ├── service/OrderService.java
│ └── web/OrderController.java
└── resources/application.yml
3.2 pom.xml
只用 Web 和测试两个依赖。注意 Boot 4 里 spring-boot-starter-web 已经标记为废弃,官方推荐换成 spring-boot-starter-webmvc,功能一样,包名变了。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>4.1.2</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>async-demo</artifactId>
<version>1.0.0</version>
<name>async-demo</name>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webmvc</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>4.1.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>4.1.2</version>
</plugin>
</plugins>
</build>
</project>
3.3 启动类
@EnableAsync 必须加,没有它所有 @Async 都是装饰品。
package com.example.asyncdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@EnableAsync
@SpringBootApplication
public class AsyncDemoApplication {
public static void main(String[] args) {
SpringApplication.run(AsyncDemoApplication.class, args);
}
}
3.4 用户上下文:一个再普通不过的 ThreadLocal
真实项目里这里放的是登录用户 ID、租户 ID、权限之类的信息。demo 里简化成一个字符串。
package com.example.asyncdemo.context;
public final class UserContext {
private static final ThreadLocal<String> CURRENT_USER = new ThreadLocal<>();
private UserContext() {
}
public static void set(String userId) {
CURRENT_USER.set(userId);
}
public static String get() {
return CURRENT_USER.get();
}
public static void clear() {
CURRENT_USER.remove();
}
}
clear() 里用的是 remove() 而不是 set(null)。前者会把整个 Entry 删掉,后者只是把值置空,Entry 还挂在 ThreadLocalMap 上,长生命周期的线程池里这就是内存泄漏。
3.5 过滤器:请求进来时写入上下文和 traceId
用请求头 X-User-Id 模拟登录态。真实项目里换成从 Token 解析就行,位置一样。
package com.example.asyncdemo.context;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.UUID;
import org.slf4j.MDC;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class UserContextFilter extends OncePerRequestFilter {
private static final String USER_HEADER = "X-User-Id";
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response,
FilterChain chain) throws ServletException, IOException {
String userId = request.getHeader(USER_HEADER);
if (userId == null || userId.isBlank()) {
userId = "anonymous";
}
String traceId = UUID.randomUUID().toString().replace("-", "").substring(0, 16);
UserContext.set(userId);
MDC.put("traceId", traceId);
MDC.put("userId", userId);
response.setHeader("X-Trace-Id", traceId);
try {
chain.doFilter(request, response);
} finally {
UserContext.clear();
MDC.clear();
}
}
}
finally 里必须清理。Tomcat 的请求线程也是复用的,不清理就会把上一个请求的用户带到下一个请求里,这种串号在生产上非常难复现。
3.6 核心配置:线程池 + 上下文装饰器
这是整篇文章最值钱的一段代码。它做了四件事:把池子命名成 Spring 认识的名字、设一个会真正扩容的有界队列、挂上上下文装饰器、配置优雅停机。
package com.example.asyncdemo.config;
import com.example.asyncdemo.context.UserContext;
import java.util.Map;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskDecorator;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@Configuration(proxyBeanMethods = false)
public class AsyncConfig {
private static final Logger log = LoggerFactory.getLogger(AsyncConfig.class);
@Bean("applicationTaskExecutor")
public ThreadPoolTaskExecutor applicationTaskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(8);
executor.setMaxPoolSize(32);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("biz-async-");
executor.setTaskDecorator(new ContextCopyingTaskDecorator());
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(30);
executor.initialize();
return executor;
}
@Bean
public AsyncConfigurer asyncConfigurer(ThreadPoolTaskExecutor applicationTaskExecutor) {
return new AsyncConfigurer() {
@Override
public Executor getAsyncExecutor() {
return applicationTaskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return (ex, method, params) ->
log.error("异步任务执行失败 method={} params={}", method, params, ex);
}
};
}
static class ContextCopyingTaskDecorator implements TaskDecorator {
@Override
public Runnable decorate(Runnable runnable) {
String user = UserContext.get();
Map<String, String> mdc = MDC.getCopyOfContextMap();
return () -> {
String previousUser = UserContext.get();
Map<String, String> previousMdc = MDC.getCopyOfContextMap();
try {
if (user != null) {
UserContext.set(user);
}
if (mdc != null) {
MDC.setContextMap(mdc);
}
runnable.run();
} finally {
if (previousUser != null) {
UserContext.set(previousUser);
} else {
UserContext.clear();
}
if (previousMdc != null) {
MDC.setContextMap(previousMdc);
} else {
MDC.clear();
}
}
};
}
}
}
几个关键决定说一下。
Bean 名字必须叫 applicationTaskExecutor。Spring MVC 的异步请求处理、GraphQL 的异步返回值、JPA 的 bootstrap 线程都按这个名字找池子。名字对不上,启动时可能直接报找不到 Bean。
decorate() 在提交任务的那个线程里执行,所以能读到调用方的 UserContext 和 MDC。真正干活的是返回的那个 lambda,它跑在池线程里。进去先备份池线程原有的值,再覆盖,最后在 finally 里还原——这样同一个池线程连续跑两个任务也不会串。
CallerRunsPolicy 的意思是队列满了就由提交线程自己跑。看着像降级,其实是保护:压测时接口会变慢,但不会有任务被悄悄扔掉。换成 DiscardPolicy 你会发现“少量订单没写审计日志”,而且查不出来。
setWaitForTasksToCompleteOnShutdown(true) 加 awaitTerminationSeconds(30) 是给发版准备的。没有这两行,容器关闭时线程池直接 shutdownNow,队列里剩下的任务全部蒸发。
这里的 AsyncConfigurer 其实只为了接管异常处理器。池子既然叫 applicationTaskExecutor,Boot 内置的逻辑本来就会把它交给 @Async 用。
3.7 异步服务:三种返回值和上下文读取
package com.example.asyncdemo.service;
import com.example.asyncdemo.context.UserContext;
import java.util.concurrent.CompletableFuture;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class AuditService {
private static final Logger log = LoggerFactory.getLogger(AuditService.class);
@Async
public void writeAuditLog(String orderNo) {
log.info("写审计日志 orderNo={} user={} thread={}",
orderNo, UserContext.get(), Thread.currentThread().getName());
}
@Async
public CompletableFuture<String> readUserInAsync() {
String user = UserContext.get();
log.info("异步线程里读用户 user={} thread={}", user, Thread.currentThread().getName());
return CompletableFuture.completedFuture(String.valueOf(user));
}
@Async
public CompletableFuture<String> slowQuery(String sku) {
try {
Thread.sleep(500);
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
return CompletableFuture.failedFuture(ex);
}
log.info("慢查询完成 sku={} user={} thread={}", sku, UserContext.get(), Thread.currentThread().getName());
return CompletableFuture.completedFuture("stock-of-" + sku);
}
}
CompletableFuture 的返回值要用 completedFuture 包一层。异步方法体是在别的线程里算的,Spring 需要一个 Future 句柄来接结果,返回裸值它接不住。方法体里写的 completedFuture 只负责把值递出去,调用方拿到的是代理生成的另一个 Future。
3.8 订单服务:故意写一个自调用
package com.example.asyncdemo.service;
import com.example.asyncdemo.context.UserContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class OrderService {
private static final Logger log = LoggerFactory.getLogger(OrderService.class);
private final AuditService auditService;
public OrderService(AuditService auditService) {
this.auditService = auditService;
}
public String createOrderBySelfCall(String orderNo) {
String callerThread = Thread.currentThread().getName();
writeAuditLog(orderNo);
return callerThread;
}
public String createOrderByProxy(String orderNo) {
String callerThread = Thread.currentThread().getName();
auditService.writeAuditLog(orderNo);
return callerThread;
}
@Async
public void writeAuditLog(String orderNo) {
log.info("这里本该异步 orderNo={} user={} thread={}",
orderNo, UserContext.get(), Thread.currentThread().getName());
}
}
createOrderBySelfCall 里的 writeAuditLog(orderNo) 等价于 this.writeAuditLog(orderNo),绕开代理,日志里的线程名会和调用方一模一样。createOrderByProxy 走的是注入进来的 auditService 代理,线程名会变成 biz-async-1。
3.9 接口层:把结果摆到台面上
package com.example.asyncdemo.web;
import com.example.asyncdemo.context.UserContext;
import com.example.asyncdemo.service.AuditService;
import com.example.asyncdemo.service.OrderService;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/orders")
public class OrderController {
private final OrderService orderService;
private final AuditService auditService;
private final ThreadPoolTaskExecutor applicationTaskExecutor;
public OrderController(OrderService orderService,
AuditService auditService,
ThreadPoolTaskExecutor applicationTaskExecutor) {
this.orderService = orderService;
this.auditService = auditService;
this.applicationTaskExecutor = applicationTaskExecutor;
}
@GetMapping("/self-call")
public Map<String, Object> selfCall(@RequestParam String orderNo) {
String callerThread = orderService.createOrderBySelfCall(orderNo);
return Map.<String, Object>of("callerThread", callerThread,
"tip", "看日志:审计那行的线程名和这里一样,说明没异步");
}
@GetMapping("/proxy")
public Map<String, Object> proxy(@RequestParam String orderNo) {
String callerThread = orderService.createOrderByProxy(orderNo);
return Map.<String, Object>of("callerThread", callerThread,
"tip", "审计那行应该变成 biz-async-1 这种线程名");
}
@GetMapping("/context")
public Map<String, Object> context() throws Exception {
CompletableFuture<String> future = auditService.readUserInAsync();
String asyncUser = future.get(3, TimeUnit.SECONDS);
return Map.<String, Object>of("callerUser", String.valueOf(UserContext.get()),
"asyncUser", asyncUser);
}
@GetMapping("/parallel")
public Map<String, Object> parallel(@RequestParam(defaultValue = "sku-1") String sku) throws Exception {
long start = System.currentTimeMillis();
CompletableFuture<String> first = auditService.slowQuery(sku);
CompletableFuture<String> second = auditService.slowQuery(sku);
CompletableFuture.allOf(first, second).get(5, TimeUnit.SECONDS);
long cost = System.currentTimeMillis() - start;
Map<String, Object> result = new LinkedHashMap<>();
result.put("first", first.join());
result.put("second", second.join());
result.put("costMillis", cost);
return result;
}
@GetMapping("/pool")
public Map<String, Object> pool() {
Map<String, Object> result = new LinkedHashMap<>();
result.put("corePoolSize", applicationTaskExecutor.getCorePoolSize());
result.put("maxPoolSize", applicationTaskExecutor.getMaxPoolSize());
result.put("poolSize", applicationTaskExecutor.getPoolSize());
result.put("activeCount", applicationTaskExecutor.getActiveCount());
result.put("queueSize", applicationTaskExecutor.getQueueSize());
result.put("queueRemaining", applicationTaskExecutor.getThreadPoolExecutor().getQueue().remainingCapacity());
return result;
}
}
3.10 配置文件
server:
port: 8080
spring:
application:
name: async-demo
logging:
pattern:
console: "%d{HH:mm:ss.SSS} %-5level [%thread] %logger{36} traceId=%X{traceId} user=%X{userId} - %msg%n"
3.11 跑起来验证
启动后依次执行四条命令:
curl -s -H "X-User-Id: 10086" "http://localhost:8080/orders/self-call?orderNo=A001"
curl -s -H "X-User-Id: 10086" "http://localhost:8080/orders/proxy?orderNo=A002"
curl -s -H "X-User-Id: 10086" "http://localhost:8080/orders/context"
curl -s -H "X-User-Id: 10086" "http://localhost:8080/orders/parallel?sku=sku-9"
第一条的日志里,这里本该异步 那行的线程名是 http-nio-8080-exec-1,和 callerThread 一致,说明同步执行了。第二条会变成 biz-async-1,user=10086 也在——装饰器把上下文带过去了。第三条返回的 callerUser 和 asyncUser 都是 10086。第四条 costMillis 只有 500 出头,两个 500 毫秒的查询并行跑完了。
如果想看队列的真实情况,压测时多刷几次 /orders/pool:queueSize 超过 200 之后 poolSize 才会往上涨,最多到 32。
四、踩坑经验:这 6 个地方最容易被忽略
第一坑:同类自调用。 上面已经演示过。修复方式有三种:把异步方法拆到另一个 Bean;注入自己(ObjectProvider<OrderService> 绕开循环依赖);用 AopContext.currentProxy() 配合 @EnableAspectJAutoProxy(exposeProxy = true)。我推荐拆 Bean,前两种都是给架构埋债。
第二坑:返回类型不是 void 或 Future。 方法声明 String,@Async 照样把任务提交出去,但拦截器只处理 void 和 Future 两种返回,其余情况直接返回 null。编译通过,测试也能过,线上就是拿不到结果。
第三坑:void 方法吞掉异常。 异步方法抛异常,调用方永远收不到。默认的异常处理器只是打一条日志,事务也不会回滚。要么在方法体里自己 try-catch,要么像 demo 那样注册 AsyncUncaughtExceptionHandler 并接进告警。
第四坑:@Async 加 @Transactional 顺序搞错。 异步方法跑在新线程里,外层事务的 ThreadLocal 根本传不过去,它开的是自己独立的事务。更麻烦的是外层事务还没提交,异步任务就去查刚插入的数据,查不到。正确做法是用 TransactionSynchronizationManager 注册 afterCommit 回调,事务提交后再提交异步任务。
第五坑:随手定义了一个 Executor Bean。 Boot 的自动配置带 @ConditionalOnMissingBean(Executor.class),你只要往容器里扔任何一个 Executor,它整套 applicationTaskExecutor 就不创建了。结果 @Async 用的是你那个不知道什么参数的小池子,MVC 异步还找不到 Bean。要么把池子命名成 applicationTaskExecutor,要么设置 spring.task.execution.mode=force 强制自动配置照常生效。
第六坑:装饰器只拷不还。 TaskDecorator 里进去设了值,finally 忘了恢复。池线程被下一个任务复用时,用户 ID 还是上一个人的。这种 bug 在日志里表现为“张三的操作记到了李四头上”,靠 code review 很难看出来,必须靠代码结构强制保证。
五、性能对比:线程池、虚拟线程怎么选
三种执行器各有各的适用面,选错了不是慢一点的问题,是会炸。
| 方案 | 线程模型 | 适合场景 | 主要风险 |
|---|---|---|---|
| SimpleAsyncTaskExecutor | 每任务新建平台线程 | 几乎不用 | 无上限,流量一大线程数失控 |
| ThreadPoolTaskExecutor | 固定核心 + 有界队列 | 通用,需要限流的场景 | 队列参数配错,扩不了容 |
| 虚拟线程执行器 | 每任务一个虚拟线程 | 阻塞 IO 多、并发高的场景 | 池参数失效,限流要靠别的组件 |
虚拟线程这块要单独说一句。打开 spring.threads.virtual.enabled=true 之后,Boot 自动配置的 applicationTaskExecutor 会变成 SimpleAsyncTaskExecutor,每个任务一个虚拟线程,core-size、max-size、queue-capacity 这些参数全部失效——文档里写得很清楚,池化参数会被忽略。
虚拟线程适合“线程大部分时间在等”的场景:等数据库、等 HTTP、等文件。一个请求里串行调五个下游服务,用虚拟线程能省掉大量线程栈内存。但它是无限流能力的,数据库连接池只有 20 个连接,你开一万个虚拟线程去抢,最后卡在连接池上,还可能把数据库打死。限流得靠 Semaphore 或者连接池本身。
CPU 密集的任务别用虚拟线程。算力就那么多核,线程再多也是排队,反而多了调度开销。这种场景固定大小的小池子最稳,corePoolSize 设成核数左右。
我自己的默认选择:新项目 JDK 21 以上、IO 等待占大头,开虚拟线程,配一个有界 Semaphore 兜底;老项目不动,把 ThreadPoolTaskExecutor 的队列改成有界、拒绝策略改成 CallerRunsPolicy,收益已经很大。
六、总结
@Async 的坑集中在三个地方,记住这三句就够用。
代理决定它生不生效。同类 this 调用、私有方法、final 方法都绕不过去,跨 Bean 调用才是正道。
线程决定上下文在不在。ThreadLocal 不跨线程,TaskDecorator 在提交那一刻抄一份带过去,用完必须还原。
参数决定它扛不扛得住。无界队列让 maxPoolSize 形同虚设,有界队列加 CallerRunsPolicy 才是能上生产的组合。
下次再遇到“方法标了异步但没异步”,别急着怀疑 Spring,先看线程名。线程名不会骗人。
参考资料
- Task Execution and Scheduling
- Annotation Interface Async
- Interface TaskDecorator
- Interface AsyncConfigurer
文 / 会编程的吕洞宾