Java 协程在 Spring Boot 中的应用：性能提升与内存优化实践

1.4 虚拟线程（协程）：鱼和熊掌可以兼得

虚拟线程的核心思想是：I/O 等待时不占资源，而 CPU 呢，只服务于正在运行的任务。

就像图书馆自习，原来每个人必须独占一张桌子（平台线程），现在改成共享座位制：只要你离开去喝水、上厕所（I/O 等待），系统立刻把你的位置释放掉，别人马上可以坐下学习。等你回来，接着从刚才的地方继续看。

这样一来，你完全可以做到'一人一单'，每个 HTTP 请求都分配一个虚拟线程，写法还是原来的同步风格，性能却堪比异步！

1.5 为什么说 JDK 21 是王炸？

关键就在于：Java 虚拟线程最大的优势不是技术先进，而是生态兼容！

如果 使用 Spring Boot 3.2+，更加简单，只需要加一行配置，就能让所有 MVC 控制器自动使用虚拟线程处理请求：

spring:
  threads:
    virtual:
      enabled: true

这才是真正的'平滑升级'：不用改代码、不用学新语法、不用换框架，性能直接起飞。

1.6 哪些场景是虚拟线程的主场？

当然，虚拟线程也不是万能药。它最擅长的是'干活少、等得多'的场景。

适合使用虚拟线程的场景：

• Web 服务端：单机支撑 10 万+ HTTP 长连接。
• 数据库访问：并发执行上千个 SQL 查询。
• 微服务聚合：并行调用多个下游接口。
• 文件批量处理：批量读取数千个小文件。

不适合使用的场景：

• CPU 密集型任务：如图像处理、加密解密。
• 长时间持有锁 >5s：可能导致底层平台线程卡住。
• 依赖 ThreadLocal 的复杂场景：需谨慎使用。

二、虚拟线程原理

2.1 M:N 调度模型

虚拟线程的核心，是 M:N 调度模型。

M 个虚拟线程（协程/'轻量任务'） → 映射到 N 个平台线程（也就是操作系统线程）上执行。

这就像开了个快递站，要送几百万个包裹（M），但你只雇了两个快递员（N）。靠的是'灵活调度'。

平台线程（Platform Thread）：就是真正的快递员，数量少，工资高。 虚拟线程（协程）（Virtual Thread）：是你派出去的'送货任务'，数量可以超多，成本极低。

JVM 在检测到以下操作时，会自动触发 Unmount（挂起）：

• Thread.sleep()
• 网络 IO（如 HTTP 请求、数据库查询）
• 文件读写
• synchronized 锁等待

一旦这些操作完成，JVM 会重新调度一个平台线程来 Mount 回来，继续执行后续逻辑。

2.2 协程和 Reactor/响应式编程比，谁更强？

结论：

• 如果你是新项目，且主要是 HTTP 接口 + DB 查询 + 微服务调用，直接上虚拟线程，简单又高效。
• 如果你需要做 实时数据流处理、背压控制、复杂事件驱动，那还是 Reactor 更合适。

三、SpringBoot 如何使用协程

3.1 Project Loom：协程背后的'发动机'

Loom 是英文多义词，核心释义分两类，且和 Project Loom 的命名寓意高度关联。

Project Loom 是 OpenJDK 旗下的核心研发项目，2017 年启动，核心目标是重构 Java 的并发模型。

其核心成果 —— 虚拟线程（Virtual Threads）已在 JDK 21 中正式发布。

只要你的 JDK 版本 ≥ Java 21（推荐），或者至少是支持虚拟线程的预览版本（如 JDK 19/20 + 启用 preview），就可以直接用了！

注意：虽然 Spring Boot 没有单独提供 'loom-starter'，但它已经原生兼容 Loom 的所有特性。

示例改造：用虚拟线程写个异步任务

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

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        try (ExecutorService executor = Executors.newVirtualThreadExecutor()) {
            for (int i = 0; i < 10_000; i++) {
                int taskId = i;
                executor.submit(() -> {
                    System.out.println("任务 " + taskId + " 正在执行，线程名：" + Thread.currentThread());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    System.out.println("任务 " + taskId + " 完成");
                });
            }
        }
        Thread.sleep(2000);
    }
}

3.2 Quasar 框架：老派但仍有拥趸的协程方案

在 Project Loom 出来之前，想在 Java 里玩协程？大多数人只能靠 Quasar。

Quasar 是一个第三方 Java 协程框架，需要通过字节码增强（instrumentation）来拦截方法调用。

当前是否还推荐使用 Quasar？

结论先行：除非你卡在老版本 JDK 上，否则没必要用 Quasar。

原因如下：

1. 需要字节码增强：必须加 -javaagent 参数启动 JVM，部署麻烦。
2. 兼容性问题多：某些反射、Lambda、第三方库可能出错。
3. 社区热度下降：自从 Loom 推出后，Quasar 基本停止维护。

3.3 实战建议：Spring Boot 中到底该怎么选？

四、与 Java Project Loom 相关的四大核心概念

JDK 21 带来的 Project Loom，是一次'操作系统级'的重构。

本章我们来拆解它的四大核心概念：

• Fibers（纤程）
• Continuations（续体）
• Virtual Threads（虚拟线程）
• Scoped Threads（作用域线程）

4.1 Continuations（续体）

Continuations（续体）是可暂停、可恢复的执行片段，本质是 'Java 调用栈的快照'。它能捕获当前代码的执行状态，暂停执行时保存状态，恢复时还原状态。

• 有栈续体（Stackful）：Loom 用的是 '有栈的 续体'，能完整保存 Java 方法调用栈。
• 底层支撑：Continuations 是 Virtual Threads/Fibers 的实现基础。

4.2 Fibers（纤程）

Fibers（纤程）是 Loom 早期对 'JVM 管理的轻量级用户态线程' 的称呼，本质是基于续体实现的、非内核调度的执行单元，是 Virtual Threads 的 '前身'。

为何后来改称 Virtual Threads？

Loom 团队为了降低开发者认知成本：'Fiber' 是新术语，而 'Virtual Thread'（虚拟线程）更直观。

4.3 Virtual Threads（虚拟线程 / 协程）

Virtual Threads 是 JDK 21 正式 GA（通用可用）的特性，是 Fibers 的标准化、可直接使用的形态。

核心优势

4.4 Scoped Threads（作用域线程）

Scoped Threads（作用域线程）是 JDK 21 中预览特性，核心是 '线程的生命周期绑定到一个作用域（Scope）'。

作用域结束时，JVM 会自动等待所有该作用域内的线程完成，或强制关闭线程，避免传统线程的 '资源泄漏' 问题。

基本使用（基于 StructuredTaskScope）

void structuredTask() throws ExecutionException, InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Future<String> f1 = scope.fork(() -> "任务 1 结果");
        Future<Integer> f2 = scope.fork(() -> 100);
        scope.join();
        scope.throwIfFailed();
        String res1 = f1.result();
        int res2 = f2.result();
    }
}

五、如何使用 Java Project Loom 的协程？三种写法全解析

好消息是：Loom 的 API 设计非常友好，几乎和老的 Thread 类一样简单。

5.1 方式一：Thread.ofVirtual ().start () —— 基础写法

直接创建虚拟线程（适合写 Demo）。

// 像创建线程对象一样创建虚拟线程，不立刻启动
Thread vt = Thread.ofVirtual().name("vt-worker-", 0).unstarted(() -> {
    System.out.println("我在虚拟线程里跑：" + Thread.currentThread());
});
vts.start();

// 或者一步到位
Thread.startVirtualThread(() -> task());

这是虚拟线程最基础的手动创建方式，专为快速验证特性、编写入门 Demo设计，不适合大规模任务场景。

5.2 方式二：ThreadFactory 工厂模式 —— 兼容级过渡写法

如果你的老代码需要 ThreadFactory，可以使用此方式。

// 如果你的老代码需要 ThreadFactory
ThreadFactory factory = Thread.ofVirtual().factory();
ExecutorService oldStylePool = Executors.newCachedThreadPool(factory);

判断是否为虚拟线程，有时候你需要做兼容判断或日志输出：

Thread current = Thread.currentThread();
if (current.isVirtual()) {
    System.out.println("当前在线程：" + current + " 是虚拟线程");
} else {
    System.out.println("当前是平台线程：" + current);
}

这个方法返回 true 表示当前运行在虚拟线程中。

5.3 方式三：Executors.newVirtualThreadPerTaskExecutor () —— 生产级首选

这是新时代的最佳实践！不要再用线程池（Pool）了，因为虚拟线程不需要"池化"（用完即销毁，不复用）。

// ⚠️ 注意：这个 Executor 是"每任务一线程"，不复用线程！
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> executor.submit(() -> {
        processRequest(i);
    }));
}
// 离开 try 块时，自动调用 close()，等待所有任务跑完

核心观念转变：

• 以前：线程很贵，要复用（Pooling）。
• 现在：线程很便宜，用完就扔。不要试图池化虚拟线程，那是画蛇添足。

JDK 21 为虚拟线程量身打造的全新执行器，彻底抛弃传统线程池的 '池化思维'，适配虚拟线程 '轻量、即用即弃、海量扩展' 的核心特性，是新系统开发的首选。

注意事项

• 仅适用于 IO 密集型任务：若任务是纯 CPU 密集型，建议用 Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())。
• 避免无限制提交任务：虽然虚拟线程轻量，但提交上亿级任务仍会产生内存开销，需结合业务限流。
• 慎用 ThreadLocal：虚拟线程数量极多，ThreadLocal 存储大对象会导致内存泄漏，建议用 JDK 21 预览特性 ScopedValue 替代。

5.4 三种方式对比与选择原则

选择原则：

1. 写 Demo / 学习 → 选方式一。
2. 老系统迁移 → 选方式二。
3. 新系统开发 / 生产落地 → 选方式三。
4. CPU 密集型任务 → 放弃虚拟线程，用传统固定大小平台线程池。