虚拟线程与 Project Loom

Project Loom 的背景与目标

Project Loom 是 OpenJDK 中一个长期运行的项目，由 Ron Pressler 领导， 目标是为 Java 引入轻量级并发原语——首先是虚拟线程，其次是结构化并发。

传统并发模型的困境

在 Java 21 之前，开发者面对高并发 I/O 有两种选择，各有代价：

Project Loom 的答案是：让「一请求一线程」模型在百万级并发下也高效运行， 同时保持同步代码的简洁性。这就是虚拟线程的核心价值。

虚拟线程的内部机制

核心概念

创建与使用虚拟线程

// 方式1：Thread.ofVirtual()（最基础的创建方式）
Thread vt = Thread.ofVirtual()
    .name("vt-1")
    .start(() -> System.out.println("虚拟线程：" + Thread.currentThread()));

// 方式2：Thread.Builder（工厂方法，可批量创建命名线程）
Thread.Builder builder = Thread.ofVirtual().name("worker-", 0);
Thread t1 = builder.start(() -> task1()); // worker-0
Thread t2 = builder.start(() -> task2()); // worker-1

// 方式3：ExecutorService（推荐用于大量任务）
try (ExecutorService vExec = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {
        final int id = i;
        vExec.submit(() -> {
            Thread.sleep(Duration.ofMillis(100)); // I/O 模拟
            return "result-" + id;
        });
    }
} // 自动等待所有任务完成

// 方式4：Spring Boot 3.2+ 一行配置启用虚拟线程（推荐）
// application.properties:
// spring.threads.virtual.enabled=true
// Tomcat/Jetty 自动将每个请求用虚拟线程处理

与平台线程的深度对比

Pinning 问题：虚拟线程的最大陷阱

Pinning（钉住）是指虚拟线程被「钉」在载体线程上，无法在阻塞时卸载， 从而阻塞载体线程，退化为平台线程的行为。

导致 Pinning 的两种情况

// Pinning 示例：synchronized 内部 I/O 阻塞
public class PinningDemo {
    private final Object lock = new Object();

    void problematic() {
        synchronized (lock) {
            // 虚拟线程在此阻塞 I/O 时被 pin 住！
            byte[] data = readFromDatabase(); // 网络 I/O
        }
    }

    // 修复：用 ReentrantLock 替换 synchronized
    private final ReentrantLock reentrantLock = new ReentrantLock();

    void fixed() {
        reentrantLock.lock();
        try {
            // ReentrantLock 内部用 LockSupport.park()，虚拟线程可以安全卸载
            byte[] data = readFromDatabase(); // 不再 pin 住
        } finally {
            reentrantLock.unlock();
        }
    }
}

检测 Pinning

// JVM 参数：检测并打印 pinning 事件
// -Djdk.tracePinnedThreads=full    详细打印堆栈
// -Djdk.tracePinnedThreads=short   只打印关键帧

// JFR 检测：使用 Java Flight Recorder 追踪 pinning
// 运行时：jcmd {pid} JFR.start settings=profile filename=recording.jfr
// 分析：查找 jdk.VirtualThreadPinned 事件

虚拟线程与 ThreadLocal 的内存考量

ThreadLocal 在虚拟线程上仍然有效，但需要注意：如果每个虚拟线程都持有大型 ThreadLocal 值， 百万个虚拟线程可能消耗大量堆内存。Java 21 的 ScopedValue（结构化并发章节详述） 提供了更轻量的替代方案。

// 虚拟线程数量统计示例
try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
    List<Future<String>> results = new ArrayList<>();
    for (int i = 0; i < 100_000; i++) {
        results.add(exec.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1)); // 模拟 I/O
            return Thread.currentThread().toString();
        }));
    }
    // 10万个虚拟线程，每个只睡眠1秒
    // 平台线程方式：需要10万个OS线程，约100GB内存！
    // 虚拟线程方式：仅需少量内存，1秒多后全部完成
    for (Future<String> f : results) f.get(); // 收集结果
}

Spring Boot 与虚拟线程

// Spring Boot 3.2+：一行开启虚拟线程
// application.yml:
// spring:
//   threads:
//     virtual:
//       enabled: true

// 或编程方式（Spring Boot 3.2+）
@Configuration
public class VirtualThreadConfig {
    @Bean
    public TomcatProtocolHandlerCustomizer<?> virtualThreadCustomizer() {
        return protocolHandler ->
            protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
    }
}

// Quarkus（需 Java 21+）
@RunOnVirtualThread  // 该 REST 端点在虚拟线程中执行
@GET
@Path("/products")
public List<Product> getProducts() {
    return productService.findAll(); // 同步代码，在虚拟线程中执行
}

虚拟线程的适用场景

本章小结

• Project Loom 是 OpenJDK 的长期项目，虚拟线程（JEP 444）在 Java 21 正式发布。
• 虚拟线程由 JVM 调度，运行在少量载体线程上，I/O 阻塞时自动卸载，释放载体线程，I/O 就绪后重新挂载执行。
• 创建方式：Thread.ofVirtual().start()、Executors.newVirtualThreadPerTaskExecutor()。
• Pinning（钉住）是主要陷阱：synchronized 块内阻塞会 pin 住载体线程，Java 24（JEP 491）已修复。
• 虚拟线程专为 I/O 密集型任务设计，CPU 密集型任务仍需平台线程。
• Spring Boot 3.2+ 一行配置即可让所有 Web 请求运行在虚拟线程上。