一文揭开JDK21虚拟线程的神秘面纱

虚拟线程快速体验

环境：JDK21 + IDEA

public static void main(String[] args) {
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        IntStream.range(0, 10_000).forEach(i -> {
            executor.submit(() -> {
                Thread.sleep(Duration.ofSeconds(1));
                return i;
            });
        });
    } 
}

运行上面的代码看下执行时间，再试下 Executors.newFixedThreadPool(20) 和 Executors.newCachedThreadPool()

不出意外的话，会发现Executors.newVirtualThreadPerTaskExecutor()运行速度最快，Executors.newCachedThreadPool()运行时系统最卡顿，Executors.newFixedThreadPool(20) 最慢。

Executors.newCachedThreadPool()卡顿是因为一个任务创建一个Platform线程，占用了太多系统资源。

Executors.newFixedThreadPool(20)运行慢是因为只有20个并发去执行1万个任务

Executors.newVirtualThreadPerTaskExecutor()类似Executors.newCachedThreadPool()，但是创建的是虚拟线程，所以在获得高并发的同时也没有占用太多系统资源。

为什么引入虚拟线程

首先，我们来看看现在的Java线程是怎样的。

java.lang.Thread 这个类我相信大家都不陌生，代表Java中的最小并发单元，即一个线程。它是Java对底层的操作系统线程（OS Thread）的封装，为了区别于OS线程，我们称之为平台线程（Platform Thread）。当我们初始化一个Thread实例时，其实就是创建了一个Platform线程并将之与一个OS线程绑定（1:1）。

这种方式存在以下问题：

OS线程是有限的，Platform线程的创建数量受限制于OS线程
因为绑定系统资源，因此线程的创建/销毁的代价都是昂贵的

这两个问题并非无解，比如，问题1的本质是垂直扩展到顶了，完全可以用水平扩展的方式解决，一台机器的OS线程不能满足需求，再增加一台便是；问题2可以通过池化技术来解决，既然线程的创建和销毁代价比较昂贵，那便将创建好的线程收集起来，推迟销毁的时机，尽量复用它。

JDK21则是在语言层面上的提供了一个替代方案，也就是本文要介绍的虚拟线程（virtual thread），熟悉linux的同学肯定知道系统线程和用户线程的区别，虚拟线程就像是JDK实现的“用户线程”，下面来重点介绍。

什么是虚拟线程

虚拟线程，可以看作是对Platform线程的轻量级封装，Platform线程和OS线程的关系是1:1，虚拟线程和Platform线程的关系则是M:N，且一般M要远远大于N。

可以直接看下虚拟线程的构造函数源码加深理解，坐标java.lang.VirtualThread#。

虚拟线程实例化


final class VirtualThread extends BaseVirtualThread {
    VirtualThread(Executor scheduler, String name, int characteristics, Runnable task) {
        super(name, characteristics, /*bound*/ false);
        Objects.requireNonNull(task);

        // choose scheduler if not specified
        if (scheduler == null) {
            Thread parent = Thread.currentThread();
            if (parent instanceof VirtualThread vparent) {
                scheduler = vparent.scheduler;
            } else {
                scheduler = DEFAULT_SCHEDULER;
            }
        }

        this.scheduler = scheduler;
        this.cont = new VThreadContinuation(this, task);
        this.runContinuation = this::runContinuation;
    }
}

private static ForkJoinPool createDefaultScheduler() {
        ForkJoinWorkerThreadFactory factory = pool -> {
            PrivilegedAction<ForkJoinWorkerThread> pa = () -> new CarrierThread(pool);
            return AccessController.doPrivileged(pa);
        };
        PrivilegedAction<ForkJoinPool> pa = () -> {
            int parallelism, maxPoolSize, minRunnable;
            String parallelismValue = System.getProperty("jdk.virtualThreadScheduler.parallelism");
            String maxPoolSizeValue = System.getProperty("jdk.virtualThreadScheduler.maxPoolSize");
            String minRunnableValue = System.getProperty("jdk.virtualThreadScheduler.minRunnable");
            if (parallelismValue != null) {
                parallelism = Integer.parseInt(parallelismValue);
            } else {
                parallelism = Runtime.getRuntime().availableProcessors();
            }
            if (maxPoolSizeValue != null) {
                maxPoolSize = Integer.parseInt(maxPoolSizeValue);
                parallelism = Integer.min(parallelism, maxPoolSize);
            } else {
                maxPoolSize = Integer.max(parallelism, 256);
            }
            if (minRunnableValue != null) {
                minRunnable = Integer.parseInt(minRunnableValue);
            } else {
                minRunnable = Integer.max(parallelism / 2, 1);
            }
            Thread.UncaughtExceptionHandler handler = (t, e) -> { };
            boolean asyncMode = true; // FIFO
            return new ForkJoinPool(parallelism, factory, handler, asyncMode,
                         0, maxPoolSize, minRunnable, pool -> true, 30, SECONDS);
        };
        return AccessController.doPrivileged(pa);
    }

可以看到，创建虚拟线程的时候，使用了一个默认的调度器（ForkJoinPool），也就是Platform的线程池，可以看到池子的几个配置参数。

最大Platform线程数：默认为系统核心数，最大为256，可以通过jdk.virtualThreadScheduler.maxPoolSize设置

这个时候，爱思考的同学可能就要问了，既然默认的最大Platform线程数为系统核心数，岂不是大大限制了并发能力？是不是要主动设置一个较大值？

答案是不需要，因为JDK在线程池的基础上实现了调度的功能。当虚拟线程启动时，调度器会将虚拟线程mount到Platform线程，此时该Platform线程被称为这个虚拟线程的carrier；当线程运行遇到IO操作需要等待时，调度器又会将虚拟现场unmount，把Platform线程释放出来给其他虚拟线程使用，不占用CPU时间。因此，对于非CPU密集的应用，很少的Platform线程就能支持大量的虚拟线程来执行任务。事实上，对于CPU密集的应用，虚拟线程并不会带来多大的提升。虚拟线程真正的应用场景是生存周期短、调用栈浅的任务，如一次http请求、一次JDBC查询。

需要明确的是，操作系统真正能同时运算的线程数也就只有逻辑CPU数，多出来的线程只能等待系统的调度获得CPU时间。

虚拟线程状态

可以看出，虚拟线程相较原先的线程状态，多了Parked、Unparked、Pinned等状态

Parked：就是前面说的mount
Unparked：就是前面说的unmount
Pinned：虚拟线程阻塞时，正常会unmount，但是在一些特殊场景下，不能unmount，此时就会进入Pinned状态：
1. 阻塞操作在 synchronized 代码块中（后续JDK可能优化这一点限制）
2. 执行 native 方法时
Pinned状态占用了Platform线程，无疑会影响性能，官方建议对于经常执行的 synchronized 代码块，最好使用java.util.concurrent.locks.ReentrantLock 替代。如果不清楚自己代码里哪些地方使用到了 synchronized 代码块，在切换使用虚拟线程时，可以添加JVM参数jdk.tracePinnedThreads帮助排查。

总结

虚拟线程特别适用如下场景：有大量的并发任务需要执行，且任务是非CPU密集的。

虚拟线程使用上和普通的线程没有太大区别，甚至因为内置了调度逻辑和线程池，可以让开发人员不用再考虑线程池的大小、拒绝策略等，尤其给框架开发者提供了新的优化思路。

对于已经使用了reactive技术的如webFlux框架，没必要再切换到虚拟线程，两者性能相当。

对于web容器如tomcat来说，本身已经使用reactor、nio等技术优化吞吐量，在小的并发数场景下，没必要切换虚拟线程，提升不大。