Java虚拟线程实战：Project Loom让并发编程更简单

前言

Java 21 正式引入虚拟线程（Virtual Threads），这是 Project Loom 的核心成果。虚拟线程让 Java 并发编程从"难"变"简"，彻底改变了高并发应用的开发方式。本文带你全面掌握虚拟线程。
一、虚拟线程 vs 平台线程

• 平台线程：对应操作系统线程，创建成本高（约1MB栈内存），数量受限
  
• 虚拟线程：JVM 管理的轻量级线程，创建成本极低（约几KB），可创建数百万个
  

1. // 平台线程：创建100万个会OOM
2. Thread platformThread = new Thread(() -> doWork());
3. platformThread.start();
5. // 虚拟线程：创建100万个轻松搞定
6. Thread virtualThread = Thread.ofVirtual().start(() -> doWork());

复制代码

二、创建虚拟线程的四种方式

1. // 方式1：Thread.ofVirtual()
2. Thread vt1 = Thread.ofVirtual().name("vt-1").start(() -> {
3.     System.out.println("Virtual thread: " + Thread.currentThread());
4. });
6. // 方式2：Thread.startVirtualThread()
7. Thread vt2 = Thread.startVirtualThread(() -> {
8.     System.out.println("Running in virtual thread");
9. });
11. // 方式3：虚拟线程 ExecutorService
12. try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
13.     executor.submit(() -> processRequest());
14.     executor.submit(() -> processRequest());
15. }
17. // 方式4：ThreadFactory
18. ThreadFactory factory = Thread.ofVirtual().factory();
19. Thread vt4 = factory.newThread(() -> doWork());
20. vt4.start();

复制代码

三、实战：高并发 HTTP 请求处理

1. // 传统方式：线程池，受限于线程数
2. ExecutorService threadPool = Executors.newFixedThreadPool(200);
4. // 虚拟线程方式：每个请求一个虚拟线程
5. @RestController
6. public class UserController {
8.     @GetMapping("/users/{id}")
9.     public User getUser(@PathVariable Long id) {
10.         // 虚拟线程会在 I/O 阻塞时自动挂起，释放载体线程
11.         return userService.findById(id);  // 数据库查询
12.     }
13. }
15. // Spring Boot 3.2+ 开启虚拟线程
16. // application.yml
17. // spring:
18. //   threads:
19. //     virtual:
20. //       enabled: true

复制代码

四、性能对比测试

1. public class PerformanceTest {
3.     // 模拟 I/O 密集型任务
4.     static void ioTask() throws InterruptedException {
5.         Thread.sleep(100);  // 模拟数据库查询
6.     }
8.     public static void main(String[] args) throws Exception {
9.         int taskCount = 10_000;
11.         // 平台线程池
12.         long start1 = System.currentTimeMillis();
13.         try (ExecutorService pool = Executors.newFixedThreadPool(200)) {
14.             List<Future<?>> futures = new ArrayList<>();
15.             for (int i = 0; i < taskCount; i++) {
16.                 futures.add(pool.submit(() -> { ioTask(); return null; }));
17.             }
18.             for (Future<?> f : futures) f.get();
19.         }
20.         System.out.println("Platform threads: " + (System.currentTimeMillis() - start1) + "ms");
21.         // 输出约：5200ms
23.         // 虚拟线程
24.         long start2 = System.currentTimeMillis();
25.         try (ExecutorService vExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
26.             List<Future<?>> futures = new ArrayList<>();
27.             for (int i = 0; i < taskCount; i++) {
28.                 futures.add(vExecutor.submit(() -> { ioTask(); return null; }));
29.             }
30.             for (Future<?> f : futures) f.get();
31.         }
32.         System.out.println("Virtual threads: " + (System.currentTimeMillis() - start2) + "ms");
33.         // 输出约：120ms，提升40倍！
34.     }
35. }

复制代码

五、注意事项

• 避免 synchronized 块：会导致虚拟线程固定（pinning），改用 ReentrantLock
  
• 不适合 CPU 密集型任务：虚拟线程优势在 I/O 密集型场景
  
• ThreadLocal 谨慎使用：大量虚拟线程时内存占用可能增加
  

1. // 错误：synchronized 导致 pinning
2. synchronized (lock) {
3.     Thread.sleep(100);  // 虚拟线程被固定，无法挂起
4. }
6. // 正确：使用 ReentrantLock
7. ReentrantLock lock = new ReentrantLock();
8. lock.lock();
9. try {
10.     Thread.sleep(100);  // 虚拟线程可以正常挂起
11. } finally {
12.     lock.unlock();
13. }

复制代码

总结

虚拟线程是 Java 并发编程的重大突破，特别适合 I/O 密集型的微服务场景。升级到 Java 21 + Spring Boot 3.2，一行配置即可享受虚拟线程带来的性能提升。

觉得有帮助请点赞收藏！有问题欢迎评论区交流
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

前排留名，哈哈哈