Java 虚拟线程：协程概念与性能提升详解

Java 虚拟线程：协程概念与性能提升详解 | 极客日志

版本	状态	主要特性
Java 19	预览功能	首次引入虚拟线程（JEP 425）
Java 20	第二次预览	优化 API 和性能（JEP 436）
Java 21 (LTS)	正式发布	成为标准功能（JEP 444）
Java 22+	持续优化	性能提升和功能增强

// 传统线程（平台线程）
Thread platformThread = new Thread(() -> {
    // 直接映射到操作系统线程
});
platformThread.start();

// 虚拟线程
Thread virtualThread = Thread.ofVirtual()
    .name("virtual-thread-1")
    .start(() -> {
        // 由 JVM 调度，不直接绑定 OS 线程
    });

线程类型	栈大小	10K 线程内存	1M 线程内存
平台线程	1MB	~10GB	~1TB
虚拟线程	400B-1KB	~4-8MB	~400-800MB

// 创建性能测试 Benchmark Mode Cnt Score Error Units
// 创建 10,000 个线程
ThreadCreation.platformThread avgt 5 1250.234 ± 45.678 ms
ThreadCreation.virtualThread avgt 5 12.567 ± 0.789 ms
// 创建速度快约 100 倍

// 上下文切换测试
ContextSwitch.platformSwitch avgt 5 1500.00 ± 200.00 ns
ContextSwitch.virtualSwitch avgt 5 50.00 ± 10.00 ns
// 切换速度快约 30 倍

public class IOBenchmark {
    // 模拟 HTTP 请求（每个请求 100ms 延迟）
    private static void mockHttpRequest() {
        try {
            Thread.sleep(100);
        } catch (Exception e) {}
    }

    public static void main(String[] args) throws Exception {
        int requestCount = 10_000;
        int threadPoolSize = 200;

        // 平台线程池限制
        // 1. 平台线程池方式
        long start1 = System.currentTimeMillis();
        try (ExecutorService executor = Executors.newFixedThreadPool(threadPoolSize)) {
            List<Future<?>> futures = new ArrayList<>();
            for (int i = 0; i < requestCount; i++) {
                futures.add(executor.submit(IOBenchmark::mockHttpRequest));
            }
            for (Future<?> f : futures) f.get();
        }
        long time1 = System.currentTimeMillis() - start1;
        System.out.println("平台线程池：" + time1 + "ms");
        // 理论最短时间：(10000/200) * 100ms = 5000ms
        // 实际结果：5000-6000ms

        // 2. 虚拟线程方式
        long start2 = System.currentTimeMillis();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<?>> futures = new ArrayList<>();
            for (int i = 0; i < requestCount; i++) {
                futures.add(executor.submit(IOBenchmark::mockHttpRequest));
            }
            for (Future<?> f : futures) f.get();
        }
        long time2 = System.currentTimeMillis() - start2;
        System.out.println("虚拟线程：" + time2 + "ms");
        // 理论最短时间：100ms + 调度开销
        // 实际结果：100-200ms
    }
}

// JVM 内部的调度机制
public class VirtualThreadScheduler {
    // 载体线程池（ForkJoinPool）
    private static final ForkJoinPool CARRIER_POOL = new ForkJoinPool(Runtime.getRuntime().availableProcessors());

    // 调度过程示意
    public void scheduleVirtualThread(VirtualThread vt) {
        // 1. 虚拟线程就绪
        // 2. 从载体池获取线程执行
        // 3. 遇到阻塞操作时：
        // a. 保存栈状态到堆
        // b. 挂起虚拟线程
        // c. 释放载体线程给其他虚拟线程
        // 4. I/O 完成时恢复执行
    }
}

// 挂起时保存的栈帧信息
class VirtualThreadContinuation {
    // 栈帧保存在堆上（小而紧凑）
    private byte[] stackChunk;
    private int stackPointer;

    // 挂起：保存现场
    void yield() {
        saveStackToHeap();
        returnToScheduler();
    }

    // 恢复：还原现场
    void run() {
        restoreStackFromHeap();
        continueExecution();
    }
}

// 方式 1：工厂方法
Thread virtualThread = Thread.startVirtualThread(() -> {
    System.out.println("Running in virtual thread");
});

// 方式 2：构建器模式
Thread.ofVirtual()
    .name("worker-", 0) // 名称和起始编号
    .unstarted(task) // 不自动启动
    .start();

// 方式 3：ExecutorService
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> future = executor.submit(() -> "result");
    String result = future.get();
}

// 方式 4：使用线程工厂
ThreadFactory virtualThreadFactory = Thread.ofVirtual().factory();
ExecutorService executor = Executors.newThreadPerTaskExecutor(virtualThreadFactory);

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    // 创建子任务
    Future<String> userTask = scope.fork(() -> fetchUser());
    Future<Integer> orderTask = scope.fork(() -> fetchOrder());

    // 等待所有任务完成
    scope.join();
    // 检查失败
    scope.throwIfFailed();

    // 获取结果
    String user = userTask.resultNow();
    Integer order = orderTask.resultNow();
}
// 作用域结束自动取消未完成的任务

public class VirtualThreadOptimization {
    // 1. 避免线程本地变量滥用
    // 不好的做法：大量虚拟线程使用 ThreadLocal
    private static final ThreadLocal<BigObject> tl = new ThreadLocal<>();

    // 好的做法：使用 ScopedValue（Java 20+）
    private static final ScopedValue<String> CONTEXT = ScopedValue.newInstance();

    // 2. 避免 synchronized 阻塞（会固定载体线程）
    public void process() {
        // 避免：
        // synchronized(this) { // 会 pin 住虚拟线程 // 长时间操作 }

        // 推荐：使用 ReentrantLock
        Lock lock = new ReentrantLock();
        lock.lock();
        try {
            // 操作
        } finally {
            lock.unlock();
        }
    }

    // 3. 合理配置载体线程数
    public void configureCarrierThreads() {
        // 默认 = Runtime.getRuntime().availableProcessors()
        System.setProperty(
            "jdk.virtualThreadScheduler.parallelism", "32"
        );
        // 最大池大小
        System.setProperty(
            "jdk.virtualThreadScheduler.maxPoolSize", "256"
        );
    }
}

// 使用虚拟线程的 Web 服务器 vs 传统线程池
@SpringBootApplication
public class WebServerBenchmark {
    // Tomcat 配置虚拟线程
    @Bean
    public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadExecutorCustomizer() {
        return protocolHandler -> {
            protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        };
    }

    // 测试结果对比
    /*
    硬件：4 核 CPU，16GB 内存
    测试工具：wrk - 1000 并发连接
    传统线程池（200 线程）：
    - 吞吐量：3,200 req/sec
    - 延迟 P95：450ms
    - CPU 使用率：65%
    - 内存使用：1.2GB
    虚拟线程：
    - 吞吐量：12,800 req/sec （4 倍提升）
    - 延迟 P95：95ms （4.7 倍降低）
    - CPU 使用率：85% （更高利用率）
    - 内存使用：350MB （70% 减少）
    */
}

// 传统方式：固定线程池
@Configuration
public class TraditionalConfig {
    @Bean
    public ExecutorService taskExecutor() {
        // 通常限制在 50-200 个线程
        return Executors.newFixedThreadPool(100);
    }
    // 瓶颈：每个线程持有一个数据库连接
    // 100 个线程 → 最多 100 个并发查询
}

// 虚拟线程方式
@Configuration
public class VirtualThreadConfig {
    @Bean
    public ExecutorService taskExecutor() {
        // 每个任务独立虚拟线程
        return Executors.newVirtualThreadPerTaskExecutor();
    }
    // 优势：虚拟线程在等待数据库响应时挂起
    // 可以处理数千个并发查询，连接池大小不变
}

public class UnsuitableScenarios {
    // 1. CPU 密集型任务
    public void cpuIntensiveTask() {
        // 虚拟线程不会带来收益
        // 甚至可能因调度开销而略慢
        // 计算质数、图像处理、复杂算法等
        // 应使用平台线程或 ForkJoinPool
    }

    // 2. 依赖 ThreadLocal 的遗留代码
    public void legacyCode() {
        // 大量虚拟线程 + ThreadLocal = 内存爆炸
        ThreadLocal<byte[]> largeBuffer = new ThreadLocal<>();
        // 推荐迁移到 ScopedValue
    }
}

// 监控虚拟线程
public class VirtualThreadMonitoring {
    public static void main(String[] args) {
        // 启用详细日志
        System.setProperty(
            "jdk.traceVirtualThreadLevel", "1"
            // 0=off, 1=info, 2=debug
        );

        // 使用 JFR 监控
        // jcmd <pid> JFR.start name=vtrace filename=vtrace.jfr
        // jcmd <pid> JFR.dump name=vtrace

        // 线程转储包含虚拟线程
        Thread.getAllStackTraces().keySet().stream()
            .filter(Thread::isVirtual)
            .forEach(System.out::println);
    }
}

Java 虚拟线程：协程概念与性能提升详解

协程与线程的基本概念区别

一、Java 虚拟线程的演进历史

二、什么是虚拟线程

核心概念

关键特性

三、性能提升机制详解

1. 内存效率对比

2. 创建和上下文切换性能

3. I/O 密集型任务性能

四、虚拟线程工作原理

调度模型

挂起/恢复机制

五、使用模式和最佳实践

1. 创建方式

2. 结构化并发（Java 21+）

3. 性能优化技巧

六、实际场景性能数据

Web 服务器性能测试

数据库连接池场景

七、限制和注意事项

1. 不适合的场景

2. 调试和监控

总结

性能提升关键数据

适用建议

版本选择

更多推荐文章

相关免费在线工具

Java 虚拟线程：协程概念与性能提升详解

协程与线程的基本概念区别

一、Java 虚拟线程的演进历史

二、什么是虚拟线程

核心概念

关键特性

三、性能提升机制详解

1. 内存效率对比

2. 创建和上下文切换性能

3. I/O 密集型任务性能

四、虚拟线程工作原理

调度模型

挂起/恢复机制

五、使用模式和最佳实践

1. 创建方式

2. 结构化并发（Java 21+）

3. 性能优化技巧

六、实际场景性能数据

Web 服务器性能测试

数据库连接池场景

七、限制和注意事项

1. 不适合的场景

2. 调试和监控

总结

性能提升关键数据

适用建议

版本选择

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具