JAVA JVM虚拟线程

• 核心概念：

(1)协作式调度

• Continuation是虚拟线程的核心，它封装了线程的执行上下文（如局部变量、程序计数器）。
• start()方法不会立即执行线程，而是将其放入调度器的任务队列。

2.Continuation 机制详解

// jdk.internal.vm.Continuation简化
public final class Continuation {
    private final Object stack;     // 协程栈数据
    private final Runnable task;    // 待执行的任务
    private ContinuationScope scope; // 协程作用域
    
    public Continuation(ContinuationScope scope, Runnable target) {
        this.scope = scope;
        this.task = target;
        this.stack = allocateStack(); // 分配协程栈（小而动态）
    }
    
    public void run() {
        if (status == INITIAL) {
            // 首次执行，进入JVM层的协程执行逻辑
            VM.continuationStart(this);
        } else if (status == SUSPENDED) {
            // 恢复执行
            VM.continuationResume(this);
        }
    }
    
    // 暂停当前协程的执行
    public static void yield() {
        VM.continuationYield(currentContinuation());
    }
}

// ForkJoinPool虚拟线程调度器的简化逻辑
class ForkJoinPool implements ExecutorService {
    // 工作线程数组（载体线程）
    private final ForkJoinWorkerThread[] workers;
    
    // 提交虚拟线程任务
    public void execute(Runnable task) {
        if (task instanceof VirtualThread) {
            VirtualThread vt = (VirtualThread) task;
            // 将任务放入工作队列
            WorkQueue queue = getWorkerQueue();
            queue.push(vt);
            // 唤醒或创建载体线程执行任务
            signalWork();
        }
    }
    
    // 载体线程执行逻辑
    final void runWorker(WorkQueue w) {
        while (scan(w)) { // 扫描任务
            Runnable task = w.pop();
            if (task instanceof VirtualThread) {
                VirtualThread vt = (VirtualThread) task;
                // 执行虚拟线程的Continuation
                vt.runContinuation();
            }
        }
    }
}

• Work-Stealing 算法：每个载体线程维护自己的任务队列，空闲时从其他队列 "窃取" 任务。
• 载体线程池：默认大小为 CPU 核心数，可通过jdk.virtualThreadScheduler.parallelism参数调整。
• 弹性伸缩：调度器会根据负载动态调整活跃载体线程数量。

1. 检测当前线程是否为虚拟线程。
2. 将阻塞操作转换为非阻塞调用（如使用 NIO Selector）。
3. 在 IO 等待期间，通过Continuation.yield()暂停虚拟线程。
4. IO 完成后，调度器恢复虚拟线程执行。

// java.lang.Thread类简化结构
public class Thread implements Runnable {
    private long nativePeer; // 指向JVM中对应的原生线程
    
    // 线程栈大小（默认由JVM决定，通常为1MB+）
    private long stackSize;
    
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    private void init(ThreadGroup g, Runnable target, String name, long stackSize) {
        // ...
        this.stackSize = stackSize;
        // 调用JVM底层创建原生线程
        start0();
    }
    
    private native void start0(); // 调用操作系统创建线程
}

• nativePeer字段指向 JVM 内部的原生线程结构。
• 每个线程默认占用较大的栈空间（如 1MB），创建成本高。
• start0()是本地方法，依赖操作系统创建线程，开销大。

// java.lang.VirtualThread类简化结构
public final class VirtualThread extends Thread {
    private final Continuation cont; // 协程实现的核心
    
    public VirtualThread(ThreadGroup group, Runnable target) {
        super(group, null, "VirtualThread", 0, false, null);
        // 创建协程上下文
        this.cont = new Continuation(VM_VTHREAD_CONTINUATION_STACK, target);
    }
    
    @Override
    public void start() {
        // 将虚拟线程提交给调度器
        scheduler.submit(this);
    }
}

• Continuation是 JVM 内部的协程实现，负责保存和恢复线程状态。
• 虚拟线程栈内存由 JVM 管理（通常 KB 级别），创建成本极低。
• start()方法仅将任务提交给调度器，不直接创建操作系统线程。

• 线程状态（RUNNABLE、BLOCKED 等）由操作系统内核管理。
• 线程阻塞时（如 IO 操作），会触发上下文切换（从用户态到内核态），成本高（约 1μs~10μs）。

// 虚拟线程调度器简化逻辑
class VirtualThreadScheduler {
    private final ExecutorService carrierThreads; // 载体线程池
    
    public void submit(VirtualThread vt) {
        // 将虚拟线程放入任务队列
        taskQueue.add(vt);
        // 唤醒载体线程执行任务
        carrierThreads.submit(() -> runTask(vt));
    }
    
    private void runTask(VirtualThread vt) {
        // 恢复虚拟线程上下文
        vt.cont.run();
    }
}

• 虚拟线程阻塞时（如 IO），JVM 通过Continuation.yield()暂停执行，释放载体线程资源。
• 载体线程可继续执行其他虚拟线程，实现多路复用，大幅提升吞吐量。
• 调度器使用 Work-Stealing 算法优化任务分配。

3. 阻塞操作处理

平台线程的阻塞

// 传统线程执行IO操作（阻塞示例）
public void readFile() throws IOException {
    try (var reader = new BufferedReader(new FileReader("data.txt"))) {
        String line;
        while ((line = reader.readLine()) != null) { // 阻塞调用
            // 处理数据
        }
    }
}

虚拟线程的阻塞

// 虚拟线程执行IO操作
public void readFile() throws IOException {
    try (var reader = new BufferedReader(new FileReader("data.txt"))) {
        String line;
        while ((line = reader.readLine()) != null) { // 虚拟线程在此处"暂停"
            // 处理数据
        }
    } // 虚拟线程恢复执行
}

1.轻量级上下文切换

2.栈内存优化

3.无锁设计

4.任务窃取

• 用户态线程：由 JVM 而非操作系统管理。
• 协作式调度：通过Continuation.yield()主动让出执行权。
• 轻量级协程：每个线程占用极小资源，支持百万级并发。