平臺(tái)線程 = 真實(shí)員工（數(shù)量少、成本高）
虛擬線程 = 臨時(shí)工（數(shù)量多、任務(wù)來(lái)了再分配真實(shí)員工干活）

Thread vt = Thread.ofVirtual()
    .name("worker")
    .start(() -> {
        System.out.println("Hello from " + Thread.currentThread());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {}
        System.out.println("Done");
    });

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

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            System.out.println("Task " + Thread.currentThread());
            return "result";
        });
    }
} // 自動(dòng)等待所有任務(wù)完成

try (ExecutorService myExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<?> future = myExecutor.submit(() -> System.out.println("Running thread"));
    future.get();
    System.out.println("Task completed");
    // ...

Semaphore sem = new Semaphore(10);
...
Result foo() {
    sem.acquire();
    try {
        return callLimitedService();
    } finally {
        sem.release();
    }
}

Thread.Builder builder = Thread.ofVirtual().name("MyThread");
Runnable task = () -> {
    System.out.println("Running thread");
};
Thread t = builder.start(task);
System.out.println("Thread t name: " + t.getName());
t.join();

Thread.Builder builder = Thread.ofVirtual().name("worker-", 0);
Runnable task = () -> {
    System.out.println("Thread ID: " + Thread.currentThread().threadId());
};

// name "worker-0"
Thread t1 = builder.start(task);   
t1.join();
System.out.println(t1.getName() + " terminated");

// name "worker-1"
Thread t2 = builder.start(task);   
t2.join();  
System.out.println(t2.getName() + " terminated");

Thread ID: 21
worker-0 terminated
Thread ID: 24
worker-1 terminated

void handle(Request request, Response response) {
    var url1 = ...
    var url2 = ...
 
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        var future1 = executor.submit(() -> fetchURL(url1));
        var future2 = executor.submit(() -> fetchURL(url2));
        response.send(future1.get() + future2.get());
    } catch (ExecutionException | InterruptedException e) {
        response.fail(e);
    }
}
 
String fetchURL(URL url) throws IOException {
    try (var in = url.openStream()) {
        return new String(in.readAllBytes(), StandardCharsets.UTF_8);
    }
}

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class VirtualThreadTest {

    // 方法一：查看當(dāng)前 JVM 內(nèi)存使用情況
    public static void printMemoryUsage(String phase) {
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
        MemoryUsage heapMemory = memoryMXBean.getHeapMemoryUsage();
        System.out.printf("[%s] Heap Memory Used: %d MB / %d MB%n",
                phase,
                heapMemory.getUsed() / (1024 * 1024),
                heapMemory.getMax() / (1024 * 1024));
    }

    // 方法二：創(chuàng)建虛擬線程執(zhí)行任務(wù)
    public static void runVirtualThreads(int taskCount) throws InterruptedException {
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        for (int i = 0; i < taskCount; i++) {
            int finalI = i;
            executor.submit(() -> {
                System.out.printf("虛擬線程[%s] 執(zhí)行任務(wù) %d%n",
                        Thread.currentThread(),
                        finalI);
                try {
                    Thread.sleep(1000); // 模擬 IO 阻塞
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        executor.shutdown();
        while (!executor.isTerminated()) {
            Thread.sleep(100);
        }
    }

    // 方法三：循環(huán)查看內(nèi)存（模擬 GC 回收效果）
    public static void monitorMemory(int seconds) throws InterruptedException {
        for (int i = 0; i < seconds; i++) {
            printMemoryUsage("監(jiān)控中");
            System.gc(); // 建議 GC，可能不會(huì)馬上執(zhí)行
            Thread.sleep(1000);
        }
    }

    // 主方法測(cè)試
    public static void main(String[] args) throws Exception {
        // 1. 初始內(nèi)存
        printMemoryUsage("初始");

        // 2. 創(chuàng)建 1 萬(wàn)個(gè)虛擬線程任務(wù)
        runVirtualThreads(100_000);

        // 3. 任務(wù)執(zhí)行后內(nèi)存
        printMemoryUsage("任務(wù)執(zhí)行后");

        // 4. 持續(xù)觀察 GC 是否回收虛擬線程
        monitorMemory(10);
    }
}

平臺(tái)線程 T1  → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value
平臺(tái)線程 T2  → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value
平臺(tái)線程 T3  → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value

載體線程 C1（平臺(tái)線程） 
   ├─ 虛擬線程 VT1 → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value
   ├─ 虛擬線程 VT2 → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value
   └─ 虛擬線程 VT3 → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value

載體線程 C2
   ├─ 虛擬線程 VT10001 → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value
   └─ 虛擬線程 VT10002 → 有自己的 ThreadLocalMap → 存儲(chǔ) BaseContext.value

// 獲取當(dāng)前用戶(hù)信息（來(lái)自平臺(tái)線程的 ThreadLocal）
String currentUser = BaseContext.getCurrentId(); // 假設(shè)這是從 ThreadLocal 拿的

// 在虛擬線程中使用時(shí)，顯式傳入
Thread.startVirtualThread(() -> {
    // 顯式使用傳入的上下文
    processUserOrder(currentUser, orderId);
});

import org.springframework.core.SpringVersion;

public class SpringVersionCheck {
    public static void main(String[] args) {
        System.out.println("Spring Framework 版本: " + SpringVersion.getVersion());
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class App {
    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(App.class, args);

        // 測(cè)試異步方法
        AsyncService service = ctx.getBean(AsyncService.class);
        service.asyncTask();
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service

class AsyncService {

    @Async

    public void asyncTask() {

        Thread thread = Thread.currentThread();

        System.out.println("線程類(lèi)型: " + (thread.isVirtual() ? "虛擬線程" : "平臺(tái)線程"));

        System.out.println("線程名稱(chēng): " + thread.getName());

    }

}

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;

public class VirtualThreadMonitor {
    public static void main(String[] args) {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();

        // 獲取當(dāng)前存活的線程總數(shù)（包括平臺(tái)線程和虛擬線程）
        long totalThreadCount = threadBean.getThreadCount();

        // 初始化虛擬線程計(jì)數(shù)器
        long virtualThreadCount = 0;

        // 遍歷當(dāng)前所有線程，檢查哪些是虛擬線程
        for (Thread thread : Thread.getAllStackTraces().keySet()) {
            if (thread.isVirtual()) {  // 如果線程是虛擬線程
                virtualThreadCount++;
            }
        }

        // 輸出結(jié)果
        System.out.println("當(dāng)前存活 虛擬線程數(shù): " + virtualThreadCount);
        System.out.println("當(dāng)前存活 總線程數(shù): " + totalThreadCount);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Slf4j
@Configuration
@EnableAsync  // 啟用 @Async 支持
public class VirtualThreadConfig implements AsyncConfigurer {

    private ExecutorService createVirtualThreadExecutor(String prefix) {
        return Executors.newThreadPerTaskExecutor(
                Thread.ofVirtual()
                        .name(prefix, 0)
                        .uncaughtExceptionHandler((thread, ex) ->
                                log.error("虛擬線程 [{}] 執(zhí)行異常", thread.getName(), ex))
                        .factory()
        );
    }

    /**
     * 用于單個(gè)用戶(hù)收藏?cái)?shù)據(jù)的異步回寫(xiě)（實(shí)時(shí)場(chǎng)景）
     */
    @Bean("favoriteRedisWriterVirtualThreadExecutor")
    public Executor favoriteUserWriteVirtualThreadExecutor() {
        log.info("初始化虛擬線程池：favoriteUserWriteVirtualThreadExecutor");
        return createVirtualThreadExecutor("vt-fav-user-write-");
    }

    /**
     * 用于批量同步收藏?cái)?shù)據(jù)到 Redis（定時(shí)任務(wù)場(chǎng)景）
     */
    @Bean("favoriteBatchWriteVirtualThreadExecutor")
    public Executor favoriteBatchWriteVirtualThreadExecutor() {
        log.info("初始化虛擬線程池：favoriteBatchWriteVirtualThreadExecutor");
        return createVirtualThreadExecutor("vt-fav-batch-write-");
    }

    @Override
    public Executor getAsyncExecutor() {
        return createVirtualThreadExecutor("vt-default-async-");
    }
}