Java虛擬線程（Virtual Threads）標志著Java在并發(fā)編程領(lǐng)域的一次重大飛躍，特別是從Java 21版本開始。這項新技術(shù)的引入旨在克服傳統(tǒng)多線程和線程池存在的挑戰(zhàn)。

多線程和線程池

在Java中，傳統(tǒng)的多線程編程依賴于Thread類或?qū)崿F(xiàn)Runnable接口。這些線程都是重量級的，因為每個線程都對應(yīng)一個操作系統(tǒng)級的線程，這意味著線程的創(chuàng)建、調(diào)度和銷毀都需要操作系統(tǒng)的深度參與，不僅耗費資源，也消耗時間。

圖片

為了優(yōu)化資源使用和提高效率，Java提供了線程池（ExecutorService等）。線程池可以重用固定數(shù)量的線程，避免了頻繁創(chuàng)建和銷毀線程的開銷。然而，即使是線程池也無法完全解決上下文切換和資源消耗的問題，尤其是在高并發(fā)場景下。此外，大量的線程創(chuàng)建還可能導(dǎo)致OutOfMemoryError。

下面是一個線程池OutOfMemoryError的例子：

public static void main(String[] args) {
    stackOverFlowErrorExample();
}

private static void stackOverFlowErrorExample() {
    for (int i = 0; i < 100_000; i++) {
        new Thread(() -> {
            try {
                Thread.sleep(Duration.ofSeconds(1L));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();
    }
}

圖片

虛擬線程引入

為了進一步提高并發(fā)編程的效率和簡化開發(fā)過程，Java19引入了虛擬線程概念。這些輕量級的線程在JVM的用戶模式下被管理，而不是直接映射到操作系統(tǒng)的線程上。這種設(shè)計使得可以創(chuàng)建數(shù)百萬個虛擬線程，而對操作系統(tǒng)資源的消耗微乎其微。

當代碼調(diào)用到阻塞操作時例如 IO、同步、Sleep等操作時，JVM 會自動把 Virtual Thread 從平臺線程上卸載，平臺線程就會去處理下一個虛擬線程，通過這種方式，提升了平臺線程的利用率，讓平臺線程不再阻塞在等待上，從底層實現(xiàn)了少量平臺線程就可以處理大量請求，提高了服務(wù)吞吐和 CPU 的利用率。

圖片

? 操作系統(tǒng)線程（OS Thread）：由操作系統(tǒng)管理，是操作系統(tǒng)調(diào)度的基本單位。

? 平臺線程（Platform Thread）：傳統(tǒng)方式使用的Java.Lang.Thread，都是一個平臺線程，是 Java 對操作系統(tǒng)線程的包裝，與操作系統(tǒng)是 1:1 映射。

? 虛擬線程（Virtual Thread）：一種輕量級，由 JVM 管理的線程。對應(yīng)的實例 java.lang.VirtualThread 這個類。

? 載體線程（Carrier Thread）：指真正負責執(zhí)行虛擬線程中任務(wù)的平臺線程。一個虛擬線程裝載到一個平臺線程之后，那么這個平臺線程就被稱為虛擬線程的載體線程。

使用虛擬線程

虛擬線程的使用接口與普通線程相似，但創(chuàng)建虛擬線程的方式略有不同。以下是幾種創(chuàng)建和使用虛擬線程的方法：

• 直接創(chuàng)建虛擬線程并運行：

// 傳入Runnable實例并立刻運行:
Thread vt = Thread.startVirtualThread(() -> {
    System.out.println("Start virtual thread...");
    Thread.sleep(10);
    System.out.println("End virtual thread.");
});

• 創(chuàng)建虛擬線程但不自動運行，而是手動調(diào)用start()開始運行：

// 創(chuàng)建VirtualThread:
Thread.ofVirtual().unstarted(() -> {
    System.out.println("Start virtual thread...");
    Thread.sleep(1000);
    System.out.println("End virtual thread.");
});
// 運行:
vt.start();

• 通過虛擬線程的ThreadFactory創(chuàng)建虛擬線程，然后手動調(diào)用start()開始運行：

// 創(chuàng)建ThreadFactory:
ThreadFactory tf = Thread.ofVirtual().factory();
// 創(chuàng)建VirtualThread:
Thread vt = tf.newThread(() -> {
    System.out.println("Start virtual thread...");
    Thread.sleep(1000);
    System.out.println("End virtual thread.");
});
// 運行:
vt.start();

直接調(diào)用start()實際上是由ForkJoinPool的線程來調(diào)度的。我們也可以自己創(chuàng)建調(diào)度線程，然后運行虛擬線程：

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 創(chuàng)建大量虛擬線程并調(diào)度:
ThreadFactory tf = Thread.ofVirtual().factory();
for (int i=0; i<100_000; i++) {
    Thread vt = tf.newThread(() -> { ... });
    executor.submit(vt);
    executor.submit(() -> {
        System.out.println("Start virtual thread...");
        Thread.sleep(Duration.ofSeconds(1L));
        System.out.println("End virtual thread.");
        return true;
    });
}

由于虛擬線程屬于非常輕量級的資源，因此，用時創(chuàng)建，用完就扔，不要池化虛擬線程。

虛線程的性能

下面我們測試一下虛線程的性能

public static void main(String[] args) {
    testWithVirtualThread();

    testWithThread(20);
    testWithThread(50);
    testWithThread(100);
    testWithThread(200);
    testWithThread(400);
}

private static long testWithVirtualThread() {
    long start = System.currentTimeMillis();
    ExecutorService es = Executors.newVirtualThreadPerTaskExecutor();
    for (int i = 0; i < TASK_NUM; i++) {
        es.submit(() -> {
            Thread.sleep(100);
            return 0;
        });
    }
    es.close();
    long end = System.currentTimeMillis();
    System.out.println("virtual thread:" + (end - start));
    return end;
}

private static void testWithThread(int threadNum) {
    long start = System.currentTimeMillis();
    ExecutorService es = Executors.newFixedThreadPool(threadNum);
    for (int i = 0; i < TASK_NUM; i++) {
        es.submit(() -> {
            Thread.sleep(100);
            return 0;
        });
    }
    es.close();
    System.out.println(threadNum + " thread:" + (System.currentTimeMillis() - start));
    es.shutdown();
}

下面是測試結(jié)果：

圖片

虛線程真是快到飛起?。?！

虛擬線程的原理

Java的虛擬線程會把任務(wù)（java.lang.Runnable實例）包裝到一個 Continuation實例中。當任務(wù)需要阻塞掛起的時候，會調(diào)用Continuation 的 yield 操作進行阻塞，虛擬線程會從平臺線程卸載。 當任務(wù)解除阻塞繼續(xù)執(zhí)行的時候，調(diào)用 Continuation.run會從阻塞點繼續(xù)執(zhí)行。下面讓我們結(jié)合Thread.ofVirtual().start()來看一下虛線程的實現(xiàn)。

當調(diào)用start()方法時，會創(chuàng)建一個虛擬線程 var thread = newVirtualThread(scheduler, nextThreadName(), characteristics(), task);

static Thread newVirtualThread(Executor scheduler,
                                   String name,
                                   int characteristics,
                                   Runnable task) {
        if (ContinuationSupport.isSupported()) {
            return new VirtualThread(scheduler, name, characteristics, task);
        } else {
            if (scheduler != null)
                throw new UnsupportedOperationException();
            return new BoundVirtualThread(name, characteristics, task);
        }
    }

核心主要在java.lang.VirtualThread類中。下面是JVM 調(diào)用VirtualThread的構(gòu)造函數(shù)：

圖片

VirtualThread 會初始化一個ForkJoinPool的Executor.

private static final ForkJoinPool DEFAULT_SCHEDULER = createDefaultScheduler(); 該方法初始化Executor線程池大小。該Executor 也就是執(zhí)行器，提供了一個默認的 FIFO 的 ForkJoinPool 用于執(zhí)行虛擬線程任務(wù)。

之后創(chuàng)建一個VThreadContinuation對象。該對象存儲作為Runnable對象運行的信息，它確保了每個并發(fā)操作都有清晰定義的生命周期和上下文。

VThreadContinuation是一種允許程序執(zhí)行被暫停并在將來某個時刻恢復(fù)的機制。虛擬線程利用VThreadContinuation來實現(xiàn)輕量級的上下文切換.

最后，該方法調(diào)用runContinuation方法。該方法在虛擬線程啟動時被調(diào)用。

JVM 把虛擬線程分配給平臺線程的操作稱為 mount（掛載），取消分配平臺線程的操作稱為 unmount（卸載）。

Continuation 組件十分重要，它既是用戶真實任務(wù)的包裝器，同時提供了虛擬線程任務(wù)暫停/繼續(xù)的能力，以及虛擬線程與平臺線程數(shù)據(jù)轉(zhuǎn)移功能，當任務(wù)需要阻塞掛起的時候，調(diào)用 Continuation 的 yield 操作進行阻塞。當任務(wù)需要解除阻塞繼續(xù)執(zhí)行的時候，則調(diào)用 Continuation 的 run 恢復(fù)執(zhí)行。

總結(jié)

虛擬線程是由 Java 虛擬機調(diào)度，它的占用空間小，同時使用輕量級的任務(wù)隊列來調(diào)度虛擬線程，避免了線程間基于內(nèi)核的上下文切換開銷，因此可以極大量地創(chuàng)建和使用。主要有以下好處：

• 虛擬線程是輕量級的，它們不直接映射到操作系統(tǒng)的線程，而是由JVM在用戶態(tài)進行管理。這種輕量級特性允許在單個JVM實例中同時運行數(shù)百萬個虛擬線程。
• 虛擬線程大大簡化了并發(fā)編程的復(fù)雜性。開發(fā)者可以像編寫順序代碼一樣編寫并發(fā)代碼，而無需擔心傳統(tǒng)線程編程中的許多復(fù)雜問題，如線程數(shù)、同步和資源競爭等。