Java 21 虚拟线程：高并发编程的新纪元

引言

长期以来，Java 的并发模型一直基于平台线程（Platform Thread），即对操作系统线程的薄封装。这种模型简单直观，但在高并发场景下却面临瓶颈：每个平台线程都需要占用大量内存（通常 1MB 栈空间），且创建和上下文切换的成本高昂。因此，我们不得不依赖线程池来复用线程，但这又带来了资源限制和复杂的调优问题。

Java 21 作为最新的 LTS 版本，正式引入了虚拟线程（Virtual Threads），这是 Project Loom 的核心成果。虚拟线程彻底改变了 Java 的并发编程方式，让开发者可以用简单的同步代码编写出高吞吐量的应用，而无需担心线程数量限制。

本文将深入介绍虚拟线程的概念、优势、使用方法以及实战中的注意事项。

什么是虚拟线程？

虚拟线程是由 JVM 管理的轻量级线程，它们不直接映射到操作系统线程。相反，多个虚拟线程可以共享少量的平台线程（称为载体线程，Carrier Thread）。当虚拟线程执行阻塞操作（如 I/O、睡眠）时，JVM 会自动将其挂起，并让载体线程去执行其他虚拟线程，从而极大提高了线程的利用率。

关键特性：

• 轻量级：每个虚拟线程仅占用几 KB 内存，可以轻松创建数百万个。
• 低成本创建：创建和销毁虚拟线程的开销极低，无需池化。
• 同步编程模型：可以使用传统的阻塞式 API，无需改为响应式或异步编程。
• 自动调度：由 JVM 的 ForkJoinPool 调度，开发者无需手动管理。

为什么需要虚拟线程？

传统平台线程的痛点：

• 线程数量受限于操作系统，通常只能创建几千个。
• 每个线程占用约 1MB 栈内存，大量线程会导致内存耗尽。
• 线程上下文切换开销大，影响性能。
• 异步编程（如 CompletableFuture、Reactor）虽然能提高吞吐量，但代码复杂，难以调试。

虚拟线程解决了这些问题，尤其适合 I/O 密集型 应用，如 Web 服务器、微服务、数据库访问等。

如何使用虚拟线程？

Java 21 提供了多种创建虚拟线程的方式。

1. 直接启动虚拟线程

Thread.startVirtualThread(() -> {
    System.out.println("Hello from virtual thread: " + Thread.currentThread());
});

2. 使用 Thread.Builder

Thread thread = Thread.ofVirtual()
    .name("my-virtual-thread")
    .start(() -> {
        System.out.println("Running in virtual thread");
    });
thread.join();

3. 使用 ExecutorService

这是最推荐的方式，尤其适合任务提交。

try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            // 模拟 I/O 操作
            Thread.sleep(Duration.ofSeconds(1));
            return "Task done";
        });
    }
} // 自动关闭

注意：Executors.newVirtualThreadPerTaskExecutor() 为每个任务创建一个新的虚拟线程，无需池化。

实战对比：平台线程 vs 虚拟线程

假设我们要执行 10,000 个任务，每个任务睡眠 1 秒（模拟 I/O）。

使用平台线程池：

try (ExecutorService executor = Executors.newFixedThreadPool(200)) {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(1000);
            return null;
        });
    }
    // 等待完成...
}

由于线程池只有 200 个线程，10,000 个任务需要分批执行，总耗时约 50 秒。

使用虚拟线程：

try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(1000);
            return null;
        });
    }
}

所有任务几乎同时启动，总耗时约 1 秒多。虚拟线程在睡眠时自动让出载体线程，使得所有任务并行等待。

注意事项与最佳实践

1. 避免 CPU 密集型任务
   虚拟线程适合 I/O 密集型任务。对于 CPU 密集型任务，虚拟线程不会带来性能提升，反而可能因为调度开销而略慢。此时应使用平台线程或并行流。

2. 谨慎使用 synchronized
   当虚拟线程在 synchronized 块中阻塞时，会固定（pin）载体线程，导致其他虚拟线程无法使用该载体线程。应改用 ReentrantLock。

   // 不推荐
   synchronized (lock) {
       Thread.sleep(1000);
   }
   
   // 推荐
   lock.lock();
   try {
       Thread.sleep(1000);
   } finally {
       lock.unlock();
   }
   

3. 不要池化虚拟线程
   虚拟线程的创建成本极低，池化反而增加复杂性。直接为每个任务创建新虚拟线程即可。

4. 使用 ThreadLocal 需谨慎
   虚拟线程支持 ThreadLocal，但由于数量巨大，可能消耗大量内存。可以考虑使用 ScopedValue（Java 21 预览）替代。

5. 监控与调试
   JDK 提供了 jcmd 和 JFR 事件来监控虚拟线程。例如 jcmd <pid> Thread.dump_to_file -format=json <file>。

总结

虚拟线程是 Java 并发编程的一次革命。它让开发者能够以同步的思维编写高并发应用，同时获得异步编程的吞吐量。随着 Java 21 的普及，虚拟线程将成为构建高吞吐量服务的标配。

如果你还在使用传统的线程池，不妨尝试将 I/O 密集型任务迁移到虚拟线程，体验其简洁与高效。未来，随着 Project Loom 的持续演进，Java 的并发模型将更加强大。

本文代码基于 Java 21，建议使用 JDK 21+ 运行。