Java Virtual Threads 完全指南：轻松掌握虚拟线程 – wiki基地

作者： /

Java Virtual Threads 完全指南：轻松掌握虚拟线程

引言：Java 并发编程的演进与挑战

在过去的几十年里，Java 凭借其“一次编写，到处运行”的理念和强大的生态系统，成为了构建企业级应用、Web 服务以及大规模并发系统的首选语言之一。然而，随着互联网应用的爆发式增长，处理海量用户请求和高并发场景成为了新的挑战。传统的 Java 并发模型，很大程度上依赖于操作系统的线程（Platform Threads），开始显露出其局限性。

传统的“一个请求一个线程”（Thread-per-request）模型直观且易于理解。当一个请求到来时，服务器分配一个线程来处理它。这个线程可能会执行业务逻辑、访问数据库、调用外部服务等。问题在于，这些操作很多时候都是 阻塞 的——线程会等待 I/O 操作（如网络请求、磁盘读写、数据库查询）完成，期间无法执行任何计算任务。

操作系统的线程是相对重量级的资源。创建线程需要分配内存（如栈空间），进行上下文切换的开销也比较高。当并发请求数量达到几千甚至几万时，服务器可能需要创建同样数量的 OS 线程。这会导致：

  1. 高内存消耗： 每个 OS 线程都需要分配相当大的栈内存（默认为几百KB到1MB），数千上万个线程的总内存开销非常巨大，容易耗尽系统资源。
  2. 高上下文切换开销： 操作系统需要在众多线程之间频繁切换，调度开销随线程数量线性增长，降低了 CPU 的有效工作时间。
  3. “阻塞”的低效性： 大量线程因等待 I/O 而阻塞，白白占用着 OS 资源，但 CPU 核心却可能处于空闲状态，无法充分利用计算能力。

为了解决这些问题，Java 社区和开发者们探索了多种方案，例如非阻塞 I/O (NIO)、CompletableFuture、反应式编程（Reactive Programming，如 Reactor、RxJava）等。这些方案通过回调、Future、Publisher/Subscriber 模型等方式，避免了线程的阻塞，提高了资源利用率。然而，这些异步非阻塞编程模型往往改变了传统的线性编程风格，使得代码变得更加复杂，可读性降低，调试也更困难。开发者需要学习新的API和思维方式，这无疑增加了开发成本和学习曲线。

有没有一种方法，既能像传统线程一样用简单直观的同步阻塞风格编写代码，又能享受异步非阻塞带来的高并发和高效率呢？

这就是 Java 虚拟线程（Virtual Threads） 诞生的背景和要解决的核心问题。虚拟线程是 Project Loom 项目的成果，旨在通过一种轻量级的、由 JVM 管理的并发单元，彻底改变 Java 处理高并发的方式，让开发者能够以更简单、更高效的方式构建可伸缩的应用程序。

什么是虚拟线程（Virtual Threads）？

虚拟线程（Virtual Threads），在 Java 21 中已成为正式的标准特性 (JEP 444)。它是一种由 JVM 负责调度的、非常轻量级的线程实现。与传统的平台线程（Platform Threads，即我们通常说的 OS 线程）不同，虚拟线程与 OS 线程之间没有一对一的映射关系。

核心概念：

  • 轻量级： 创建虚拟线程的开销非常小，几乎可以忽略不计。它们的栈内存占用非常小（通常只有几百字节），不像 OS 线程需要几百KB到1MB。
  • JVM 调度： 虚拟线程的生命周期和调度完全由 JVM 控制，而不是操作系统。
  • 多对少映射： 大量的虚拟线程（可能是几千、几十万甚至数百万）可以被映射到少量的底层 OS 线程（通常称为“载体线程” – Carrier Threads）上执行。

可以把虚拟线程想象成运行在平台线程之上的“用户态”线程。它们提供了 java.lang.Thread 类的所有 API，所以现有的大部分依赖于 Thread API 的代码可以无缝切换或仅需少量修改即可使用虚拟线程。

虚拟线程的工作原理：“挂载”与“卸载”

理解虚拟线程的关键在于理解它是如何在底层的少量载体线程上运行的。

当一个虚拟线程执行计算任务时，它会“挂载”到（mount）一个可用的载体线程上运行。载体线程通常是 JVM 内部管理的一个由平台线程组成的线程池，默认情况下使用 ForkJoinPool。

当这个虚拟线程执行一个 阻塞 I/O 操作 时（例如，等待网络连接、读取文件、执行数据库查询等），传统的平台线程会直接阻塞，并一直占用着这个 OS 线程。但虚拟线程的行为完全不同：

  1. 当虚拟线程遇到阻塞点时，JVM 会检测到这一点（通常是通过特殊的非阻塞 I/O 调用实现，但这对于开发者是透明的）。
  2. JVM 会将这个虚拟线程从其当前执行的载体线程上“卸载”（unmount）。虚拟线程的状态（包括程序计数器、局部变量等）会被保存起来。
  3. 这个载体线程被立即释放，可以去执行队列中的其他等待运行的虚拟线程。
  4. 当阻塞的 I/O 操作完成后（例如，网络数据到达），操作系统会通知 JVM。
  5. JVM 会找到之前被卸载的虚拟线程，并尝试将其“挂载”到 任意 可用的载体线程上，从之前中断的地方继续执行。

通过这种“挂载-卸载”机制，少量的载体线程可以高效地“轮流”服务大量的虚拟线程。当一个虚拟线程阻塞时，它只是“暂时离开”载体线程，不占用 OS 线程资源；一旦准备好再次运行，它可以迅速找到一个空闲的载体线程继续。这意味着你可以创建数十万甚至数百万个虚拟线程，而底层只需要几十个或几百个平台线程作为载体，大大减少了 OS 线程的数量和相关的开销。

这与传统的异步编程模型（如 NIO）有异曲同工之妙，它们都避免了线程的阻塞。但虚拟线程的优势在于，它将复杂的异步状态管理隐藏在 java.lang.Thread 的 API 之下，让你可以继续使用简单直观的同步阻塞风格编写代码，而底层的运行时会自动处理线程的挂起和恢复。

如何创建和使用虚拟线程？

Java 提供了多种方式来创建和使用虚拟线程，非常简单直观：

方式一：使用 Thread.ofVirtual() 构建器 (推荐)

这是创建单个虚拟线程最直接和灵活的方式。它返回一个 Thread.Builder.OfVirtual 实例，你可以像构建普通线程一样配置它，然后启动。

“`java
import java.util.concurrent.*;

public class VirtualThreadDemo1 {

public static void main(String[] args) throws InterruptedException {

    Runnable task = () -> {
        System.out.println("Hello from virtual thread: " + Thread.currentThread());
        try {
            // 模拟一个阻塞 I/O 操作，虚拟线程会在这里被卸载
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Goodbye from virtual thread: " + Thread.currentThread());
    };

    // 创建并启动一个虚拟线程
    Thread virtualThread = Thread.ofVirtual().start(task);

    // 我们可以创建很多这样的虚拟线程
    System.out.println("Main thread creating virtual thread...");

    // 等待虚拟线程结束
    virtualThread.join();

    System.out.println("Virtual thread finished. Main thread exiting.");
}

}
“`

运行上述代码，你会看到输出中虚拟线程的名称格式与传统线程不同，通常包含 virtual 字样，并且可能有一个 #编号。Thread.currentThread() 在虚拟线程内部调用时，返回的就是该虚拟线程的实例。

你也可以先构建但不立即启动：

java
Thread virtualThreadNotStarted = Thread.ofVirtual().unstarted(task);
// ... later ...
virtualThreadNotStarted.start();
virtualThreadNotStarted.join();

方式二：使用 Executors.newVirtualThreadPerTaskExecutor()

这是创建大量短生命周期任务的虚拟线程并提交执行的推荐方式，特别适合服务处理大量并发请求的场景。它返回一个 ExecutorService，每次提交一个任务 (Runnable 或 Callable)，都会为该任务创建一个新的虚拟线程来执行。

“`java
import java.util.concurrent.*;

public class VirtualThreadDemo2 {

public static void main(String[] args) throws InterruptedException {

    int numberOfTasks = 10_000; // 尝试创建大量任务

    // 创建一个 ExecutorService，每次提交任务都创建一个新的虚拟线程
    try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {

        System.out.println("Submitting " + numberOfTasks + " tasks to virtual thread executor...");

        for (int i = 0; i < numberOfTasks; i++) {
            final int taskId = i;
            executor.submit(() -> {
                // System.out.println("Task " + taskId + " running in virtual thread: " + Thread.currentThread());
                try {
                    // 模拟阻塞操作
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                // System.out.println("Task " + taskId + " finished.");
            });
        }

        // 注意：对于newVirtualThreadPerTaskExecutor，最好不要调用shutdownNow()
        // 调用shutdown() 会等待所有已提交的任务完成
        executor.shutdown();
        System.out.println("Executor shutdown initiated. Waiting for tasks to complete...");
        executor.awaitTermination(1, TimeUnit.MINUTES); // 等待一段时间确保任务完成

        System.out.println("All tasks finished. Main thread exiting.");

    } // try-with-resources 会自动关闭 executor

}

}
“`

运行这段代码，你可以尝试将 numberOfTasks 设置得非常大（例如 10,000 或更多）。你会发现程序能够轻松启动并管理如此大量的“线程”，而传统的平台线程池很难承受这么大的数量而不会耗尽资源或性能急剧下降。通过 JMC 或其他监控工具，你会发现 OS 线程的数量保持在一个相对较低的水平（通常几十或几百），与虚拟线程的数量形成鲜明对比。

方式三：使用 Thread.startVirtualThread(Runnable)

这是一个更简洁的快捷方法，用于直接创建并启动一个执行指定 Runnable 任务的虚拟线程。

“`java
import java.util.concurrent.TimeUnit;

public class VirtualThreadDemo3 {

public static void main(String[] args) throws InterruptedException {

    Runnable task = () -> {
        System.out.println("Running in quick virtual thread: " + Thread.currentThread());
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Finished quick virtual thread.");
    };

    System.out.println("Starting quick virtual thread...");
    Thread virtualThread = Thread.startVirtualThread(task); // 创建并启动

    virtualThread.join(); // 等待完成

    System.out.println("Quick virtual thread finished. Main exiting.");
}

}
“`

这是创建单个短期虚拟线程最简单的方式，但如果你需要更复杂的配置（如线程名称、未启动状态等），则应使用 Thread.ofVirtual() 构建器。

虚拟线程的核心优势

使用虚拟线程带来了多方面的重要优势：

  1. 极高的可伸缩性 (Scalability)： 这是虚拟线程最突出的优势。你可以轻松创建并运行数十万甚至数百万个虚拟线程，而底层只需要几十到几百个 OS 线程作为载体。这使得基于阻塞 I/O 的服务器能够轻松处理海量并发连接，极大提高了系统的吞吐量。
  2. 简化编程模型 (Simplified Programming)： 虚拟线程允许你继续使用传统的、顺序的、阻塞式的编程风格来编写高并发代码。无需学习复杂的异步 API、回调链或响应式流。代码更直观、更容易理解、更容易编写和维护。例如，处理一个 Web 请求，你可以写一个简单的同步方法，里面调用阻塞的网络客户端、阻塞的数据库驱动等，而运行时会负责高效地调度这些阻塞的虚拟线程。
  3. 更高的资源利用率 (Better Resource Utilization)： 因为阻塞的虚拟线程不会占用 OS 线程资源，CPU 核心可以更有效地用于执行那些非阻塞或已就绪的虚拟线程，减少了因大量阻塞线程导致的 CPU 浪费和上下文切换开销。
  4. 降低开发和维护成本 (Lower Development Cost)： 使用熟悉的 Thread API 和编程范式，降低了学习曲线。调试也变得更容易，因为你可以像调试普通线程一样设置断点、查看堆栈跟踪（尽管在高并发下查看所有虚拟线程的状态可能需要一些技巧）。
  5. 更好的可观察性 (Improved Observability): JVM 提供了更好的工具支持来观察虚拟线程的行为，例如 JFR (Java Flight Recorder) 可以记录虚拟线程的生命周期事件，线程 Dump 也能包含虚拟线程的信息，尽管可能需要过滤和特殊处理。

虚拟线程与平台线程的对比

下表总结了虚拟线程与传统平台线程的主要区别：

特性 平台线程 (Platform Thread) 虚拟线程 (Virtual Thread)
映射 1:1 映射到操作系统线程（重量级） M:N 映射到少量平台线程（轻量级，由 JVM 管理）
创建成本 高（需要 OS 调用，分配大量栈内存） 低（几乎忽略不计，分配少量堆内存）
内存消耗 高（栈内存通常几百KB – 1MB） 低（栈内存通常几百字节）
数量限制 受限于操作系统资源，通常几千个是上限 理论上可创建数百万个，受限于堆内存
调度 由操作系统调度器负责 由 JVM 调度器负责（通常使用 ForkJoinPool 作为载体）
阻塞行为 阻塞 OS 线程，占用 OS 资源 遇到阻塞 I/O 时卸载，释放载体线程，不占用 OS 资源
适用场景 CPU 密集型任务，需要 OS 调度控制，与本地代码交互 I/O 密集型任务，处理高并发阻塞操作，大规模并发请求
API new Thread() / Thread.start() Thread.ofVirtual().start() / Executors.newVirtualThreadPerTaskExecutor() / Thread.startVirtualThread()
中断 支持，行为与传统线程一致 支持，行为与传统线程一致
ThreadLocal 支持 支持，但使用需谨慎，可能导致内存泄漏或意外行为（后面会讨论）

什么时候使用虚拟线程？

虚拟线程最适合的场景是那些涉及大量 阻塞 I/O 操作 的高并发应用。例如：

  • 网络服务/Web 服务器： 处理大量并发的 HTTP 请求，每个请求可能涉及调用外部服务、访问数据库、读写文件等。
  • 微服务架构： 一个服务可能需要并发调用多个下游服务来聚合数据。
  • 数据库访问： 并发执行大量数据库查询和更新。
  • 消息队列消费者： 并发处理来自消息队列的多个消息。
  • 任何需要等待外部系统响应的任务。

在这些场景下，使用虚拟线程可以让你继续用易于理解的同步阻塞代码风格编写业务逻辑，同时获得极高的并发处理能力和系统吞缩量。

什么时候不适合或需要谨慎使用虚拟线程？

虽然虚拟线程非常强大，但并非银弹。有些场景下使用平台线程可能更合适，或者使用虚拟线程需要注意一些问题：

  1. CPU 密集型任务： 虚拟线程的主要优势在于高效处理阻塞。如果你的任务是纯粹的 CPU 计算，并且需要长时间占用 CPU 核，那么创建大量虚拟线程并不会带来额外的性能提升，因为它们最终还是要竞争底层的少数 CPU 核。在这种情况下，使用固定数量的平台线程（通常是 CPU 核数或略多于核数）组成的线程池可能更有效，因为 OS 调度器在分配 CPU 时间片给计算密集型任务方面通常更优化。
  2. 长时间持有锁或 synchronized 块： 如果虚拟线程在执行同步代码块 (synchronized) 或持有显式锁 (ReentrantLock 等) 的同时发生了阻塞（例如，在 synchronized 块内进行 I/O 操作），这个虚拟线程会变得“固定”（Pinned）在其载体线程上。这意味着直到它退出同步块或释放锁，这个载体线程都不能被其他虚拟线程使用，从而失去了虚拟线程“卸载”的优势，可能导致载体线程池的利用率下降。应尽量避免在阻塞 I/O 操作时持有锁。
  3. 使用 ThreadLocal： 虽然虚拟线程支持 ThreadLocal，但考虑到虚拟线程的数量可能非常巨大，大量使用 ThreadLocal 可能会导致显著的内存消耗。每个虚拟线程的 ThreadLocal 变量都会占用堆内存。对于海量虚拟线程的场景，应仔细评估 ThreadLocal 的使用，考虑是否有其他更节省内存的方式（如方法参数传递）。另外，一些传统的、为平台线程设计的库可能对 ThreadLocal 的行为有隐含假设，需要注意兼容性。
  4. 本地方法 (Native Methods)： 如果虚拟线程调用了执行时间较长的本地方法，它也可能导致载体线程被“固定”，因为 JVM 无法在本地方法执行期间卸载虚拟线程。
  5. 需要精细控制 OS 调度的场景： 某些特殊应用可能需要利用 OS 线程的优先级、亲和性等特性来做非常底层的调度优化，这在由 JVM 调度的虚拟线程上难以实现。

关于“固定”（Pinning）： 固定是使用虚拟线程时一个需要特别注意的问题。当虚拟线程被固定在载体线程上时，它就像一个传统的平台线程一样阻塞了载体线程，阻止了载体线程去执行其他虚拟线程。导致固定的常见原因是：
* 在执行 synchronized 方法或块时调用了可能阻塞的方法（特别是 I/O）。
* 调用了本地方法。
* ReentrantLock 等显式锁本身不会导致固定，除非你在持有锁期间执行了会引起 JVM 卸载的阻塞操作。然而，最佳实践仍然是尽量避免在持有任何锁的情况下执行阻塞操作。

JVM 提供了诊断工具（如 JFR 事件 jdk.VirtualThreadPinned）来帮助识别固定的位置。在大多数 I/O 密集型应用中，只要遵循避免在同步块中阻塞 I/O 的原则，固定通常不是一个大问题。

对现有代码的影响

对于大多数使用标准 Java API 进行 I/O 操作的现有代码，迁移到使用虚拟线程通常非常顺利。例如，使用 java.io, java.net, java.nio.channels.SocketChannel 的阻塞模式, JDBC 驱动等的代码，可以直接在虚拟线程中运行并自动受益于虚拟线程的高效率。

你可能只需要修改创建线程或管理线程池的部分：

  • 将 new Thread(task).start() 替换为 Thread.ofVirtual().start(task) 或 Thread.startVirtualThread(task)。
  • 将 Executors.newFixedThreadPool(...) 或 Executors.newCachedThreadPool() 替换为 Executors.newVirtualThreadPerTaskExecutor()。

然而，如果你的代码大量依赖前面提到的可能导致固定的模式（如在 synchronized 块中执行阻塞 I/O），或者过度依赖 ThreadLocal，可能需要进行一些重构。

调试与可观察性

虽然虚拟线程数量庞大，但 Java 提供了工具来帮助调试和监控它们：

  • 线程 Dump (jstack 或 jcmd <pid> Thread.dump)： 传统的线程 Dump 工具已经更新，可以显示虚拟线程的信息。然而，由于数量巨大，完整的 Dump 可能非常庞大，需要工具或脚本来帮助分析。
  • JMC (Java Mission Control) 和 JFR (Java Flight Recorder)： JFR 是强大的运行时诊断工具，可以记录虚拟线程的生命周期事件（创建、启动、结束）、调度事件，甚至可以捕获 jdk.VirtualThreadPinned 事件来诊断固定问题。JMC 提供了一个友好的界面来可视化 JFR 记录的数据。
  • Debugger： 大部分现代 Java IDE 的调试器都支持虚拟线程。你可以在虚拟线程中设置断点，单步执行，查看变量，就像调试普通线程一样。

虚拟线程与结构化并发 (Structured Concurrency)

值得一提的是，虚拟线程与 JEP 453 结构化并发 (Structured Concurrency) 是相辅相成的。结构化并发是一种新的编程范式和 API ( java.util.concurrent.StructuredTaskScope)，旨在简化并发任务的取消、错误处理和结果组合。

当你在一个任务中启动多个子任务（通常是并发执行）时，结构化并发能够确保：

  • 当父任务取消时，所有子任务也会被取消。
  • 当任何一个子任务失败时，其他子任务也会被取消，并且父任务能够轻松获取错误信息。
  • 父任务会在所有子任务完成后才结束（或在某些子任务失败/取消后立即结束并清理）。

这就像方法调用形成了堆栈结构一样，结构化并发为并发任务建立了一种父子层次结构和生命周期管理。结合虚拟线程的轻量级特性，你可以轻松地为每个子任务创建一个虚拟线程，利用结构化并发来优雅地管理它们的生命周期，编写出既高效又健壮的并发代码。例如，处理一个需要并行调用多个外部服务的请求时，可以在一个 StructuredTaskScope 中为每个服务调用启动一个虚拟线程，从而实现简洁且容错的并行处理。

“`java
// 伪代码示例，需要 Java 21+
import java.util.concurrent.*;

public class StructuredConcurrencyDemo {

public static void main(String[] args) throws Exception {

    // 创建一个任务范围，子任务失败时，范围会关闭并取消其他子任务
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

        Future<String> result1 = scope.fork(() -> {
            System.out.println("Task 1 started in " + Thread.currentThread());
            Thread.sleep(1000); // 模拟工作
            System.out.println("Task 1 finished.");
            return "Result A";
        });

        Future<String> result2 = scope.fork(() -> {
            System.out.println("Task 2 started in " + Thread.currentThread());
            Thread.sleep(1500); // 模拟工作
            // throw new RuntimeException("Task 2 failed!"); // 模拟失败
            System.out.println("Task 2 finished.");
            return "Result B";
        });

        // 等待所有子任务完成 (或其中一个失败)
        scope.join().throwIfFailed();

        // 获取结果
        String finalResult = result1.get() + " + " + result2.get();
        System.out.println("Combined Result: " + finalResult);

    } // 范围退出，确保所有子任务都已结束

    System.out.println("Structured concurrency demo finished.");
}

}
``
在这个示例中，scope.fork()方法很自然地与虚拟线程结合使用，因为为每个子任务创建一个独立的虚拟线程是高效且合理的。StructuredTaskScope` 则负责管理这些虚拟线程的生命周期和协作。

总结

Java 虚拟线程是 Java 平台在并发领域迈出的重要一步。它巧妙地结合了传统阻塞编程的简单性与异步非阻塞模型的高效率和可伸缩性。通过引入由 JVM 管理的轻量级虚拟线程，Java 应用程序现在能够以极低的资源开销处理海量并发任务，尤其是在 I/O 密集型场景下，极大地提高了应用的吞吐量和可伸缩性。

掌握虚拟线程意味着你可以：

  • 用更少、更易读的代码编写高并发应用。
  • 轻松应对从几千到几百万并发连接的挑战。
  • 充分利用现代多核 CPU 的计算能力，即使面临大量阻塞 I/O。

虚拟线程是 Java 平台应对现代高并发挑战的核心武器。理解并拥抱这一特性，将使你在构建高性能、高可伸缩的 Java 应用时如虎添翼。从 Java 21 起，虚拟线程已成为标准功能，现在正是深入学习和应用它的最佳时机。通过本文的指南，相信你已经对虚拟线程有了全面的认识，可以开始在自己的项目中轻松掌握并应用这一强大技术了！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部