虚拟线程：把阻塞变成廉价

挂载、卸载与 Continuation01

每个虚拟线程内部持有一个 Continuation，它保存了虚拟线程的栈帧。运行时的大致路径是：

1. start() 把虚拟线程提交给调度器，调度器把它放进载体线程的任务队列。
2. 载体线程执行 Continuation.run()，虚拟线程开始运行。
3. 遇到可卸载的阻塞点（如 Socket 读、Thread.sleep、LockSupport.park），运行时把当前栈帧冻结进 Continuation，run() 返回。
4. 载体线程从队列取下一个任务；阻塞条件满足后，调度器把虚拟线程重新排队，等某个载体线程挂载。

Thread t = Thread.ofVirtual()
    .name("worker-", 1)
    .start(() -> {
        System.out.println("virtual=" + Thread.currentThread().isVirtual());
        System.out.println("carrier=" + Thread.currentThread().toString());
        try { Thread.sleep(100); } catch (InterruptedException e) { }
    });
t.join();

载体线程的名字形如 ForkJoinPool-1-worker-1。注意：不要把载体线程当成虚拟线程的身份，也不要缓存 Thread.currentThread() 到 ThreadLocal 后跨阻塞点使用。

Pinning：JDK 21 的头号雷区02

当虚拟线程在阻塞时无法卸载，它就会钉住（pin）载体线程。被钉住的载体线程无法去执行其他虚拟线程，吞吐会退化回平台线程模型。

// JDK 21：这段代码会 pin 住载体线程
synchronized (lock) {
    Thread.sleep(Duration.ofSeconds(1)); // 卸载失败
}

// 改为 ReentrantLock，阻塞点可正常卸载
lock.lock();
try {
    Thread.sleep(Duration.ofSeconds(1));
} finally {
    lock.unlock();
}

检测方式：启动参数 -Djdk.tracePinnedThreads=full 会打印钉住时的栈；JFR 打开 jdk.VirtualThreadPinned 事件可以统计频率和持续时间。JDK 21 的 JFR 事件默认阈值是 20ms。

调度器与并行度03

虚拟线程调度器默认是一个 ForkJoinPool，并行度等于 Runtime.getRuntime().availableProcessors()。它只负责运行虚拟线程，不负责限制业务并发。

# 查看/调整调度器并行度（一般不需要改）
-Djdk.virtualThreadScheduler.parallelism=8
-Djdk.virtualThreadScheduler.maxPoolSize=256

# 诊断 pinning
-Djdk.tracePinnedThreads=full

• parallelism 是同时运行的载体线程数，默认等于 CPU 核数；把它调大不会让 CPU 变多。
• maxPoolSize 是载体线程池上限，主要应对阻塞导致的临时扩容。
• 不要用 -XX:ActiveProcessorCount 之外的方式「给虚拟线程留核」，调度器与业务线程池共享 CPU。

迁移路线：先换执行器，再查 pinning01

1. 第一步：替换线程池。把 Executors.newFixedThreadPool(n) 换成 Executors.newVirtualThreadPerTaskExecutor()，保持任务代码不变。
2. 第二步：限制稀缺资源。用 Semaphore 或连接池限制数据库/HTTP 并发，不要用线程池大小充当限流。
3. 第三步：扫描 pinning。打开 jdk.tracePinnedThreads=full 或 JFR，把 synchronized 中的阻塞调用改成 ReentrantLock。
4. 第四步：压测与观测。观察吞吐、延迟分位、载体线程数、连接池等待时间，确认瓶颈已转移。

// Before：固定线程池，队列堆满后开始拒绝
ExecutorService pool = Executors.newFixedThreadPool(200);

// After：每个任务一个虚拟线程，任务结束即销毁
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofMillis(50));
            return "ok";
        });
    }
} // close() 等待所有任务结束

ExecutorService 在 Java 19 起实现 AutoCloseable，close() 会先停止接收新任务，再等待已提交任务完成。try-with-resources 是比 shutdown() + awaitTermination() 更简洁的写法。

用信号量给下游限流02

public class DownstreamGate {
    private static final Semaphore DB_PERMITS = new Semaphore(20);

    static String query(String id) throws Exception {
        DB_PERMITS.acquire();
        try {
            return callDatabase(id); // 只有 20 个虚拟线程能同时进入
        } finally {
            DB_PERMITS.release();
        }
    }
}

• 虚拟线程数量可以是十万，但数据库连接只有几十个；信号量把「等待」留在虚拟线程层，避免连接池超时。
• 不要让信号量许可数大于连接池上限，否则等待会转移到连接池，观测上更难定位。
• HTTP 客户端自身通常有连接池，优先使用客户端内置限制，信号量用于没有内置限制的资源。

可运行示例：十万次阻塞任务03

import java.time.Duration;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class VirtualThreadsDemo {
    public static void main(String[] args) throws Exception {
        AtomicInteger done = new AtomicInteger();
        long start = System.nanoTime();

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < 100_000; i++) {
                executor.submit(() -> {
                    Thread.sleep(Duration.ofMillis(10));
                    done.incrementAndGet();
                    return null;
                });
            }
        }

        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("done=" + done.get());
        System.out.println("elapsedMs=" + ms);
        System.out.println("isVirtual=" + Thread.ofVirtual().unstarted(() -> {}).isVirtual());
    }
}

done=100000
elapsedMs≈1200（取决于机器，远小于 100000×10ms 的串行时间）
isVirtual=true

十万个任务各睡 10ms，若串行需要 1000 秒；虚拟线程让它们在等待时互相让出载体线程，总耗时接近「任务提交 + 调度」的开销。实际数字受 CPU、内存和调度器影响，但量级差异就是这个特性的意义。

先猜再看：三个高频误解01

费曼自检：能否讲清因果02