在后端开发的黄金时代，我们曾认为 ThreadPoolExecutor 就是并发的终点。但随着云原生和高性能计算的爆发，开发者们发现：线程不仅贵，而且慢。

从 JDK 8 到 JDK 21，Java 走了九年，终于补齐了与 Go 和 Rust 在高并发战场的代差。今天，我们把这三大顶级玩家放在一起，拆解它们在并发模型上的“暴力美学”。

---

1. Java 的进化：从“节流”到“开源”

JDK 8：精打细算的“池化”时代

在 JDK 8 中，线程是珍贵的。一个 Thread 映射一个 OS 内核线程。

• 痛点： 并发 1 万请求？内存先炸（10GB+）。

• 策略： 池化复用。开发者必须小心翼翼地配置 CorePoolSize 和 Queue，生怕线程池被打满导致系统雪崩。

JDK 21：Project Loom 的“降维打击”

JDK 21 引入了虚拟线程 (Virtual Threads)。

• 设计思路： 既然 OS 线程贵，JVM 就自己在用户态造出几百万个“假线程”。

• 代码架构： 抛弃复杂的异步回调（如 CompletableFuture），回归最原始的阻塞式写法。

• 核心实现： Continuation (延续性)。当虚拟线程遇到 I/O 阻塞，JVM 将其调用栈（Stack）保存到堆中，释放物理线程（载体线程）去干别的，等 I/O 回来再恢复。

Java

// JDK 21：这种写法将终结线程池调优的噩梦
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 1_000_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1)); // 虽然是阻塞，但它是虚拟的！
            return i;
        });
    });
}

---

2. Go 的基石：G-P-M 模型的极简哲学

Go 为什么能统治云原生（Docker, K8s）？因为它天生就快。

• 设计思路： G-P-M 模型。

  • G (Goroutine): 极轻量协程（初始 2KB）。

  • P (Processor): 逻辑处理器，自带本地队列，减少全局锁竞争。

  • M (Machine): 绑定 OS 线程。

• 杀手锏：Work Stealing (任务窃取)。如果一个 P 闲着，它会从邻居那里“偷”任务干，把 CPU 压榨到极致。

对比 Java： Go 的调度是“原生”的，整个标准库都是非阻塞的。而 Java 的虚拟线程是为了“挽救”那些庞大的老旧阻塞代码库。

---

3. Rust 的降临：无畏并发与零成本抽象

最近爆火的软件（如分布式流数据库 RisingWave、高性能代理 Linkerd）为何清一色选择 Rust？

核心机制：无栈协程 (Stackless) 与状态机

不同于 Java 和 Go 还需要为每个协程分配几 KB 的栈空间，Rust 的 async/await 极其硬核：

• 编译器魔法： Rust 在编译时会将异步函数转化成一个状态机 (State Machine)。

• 零成本： 它不占用独立栈内存，只有在执行时才分配最少限度的空间。这意味着 Rust 能承载的并发量，理论上是物理极限。

安全防线：所有权系统

在 Java 或 Go 里，两个线程抢一个变量导致崩溃是常事。但在 Rust 中：

• Send/Sync 特性： 编译器在编译阶段就会告诉你：“嘿，这个数据在线程间传递不安全，不准运行！”

• 这就是“无畏并发”： 只要代码能编译通过，它几乎百分之百没有并发 Bug。

Rust

// Rust + Tokio：最近高性能基础设施的首选
#[tokio::main]
async fn main() {
    let task = tokio::spawn(async {
        // 这里的任务是一个极其精简的状态机
        println!("Hello from high-performance Rust!");
    });
    task.await.unwrap();
}

---

4. 终极对决：我该怎么选？

为了方便大家决策，我整理了这张对比表：

维度	Java 21 (Loom)	Go (Goroutine)	Rust (Tokio/Async)
并发载体	虚拟线程 (有栈)	协程 (有栈)	异步任务 (无栈状态机)
内存开销	较小 (取决于堆大小)	极小 (2KB 起步)	微乎其微 (按需分配)
调度性能	优秀 (ForkJoin 调度)	极强 (原生 G-P-M)	巅峰 (零 runtime 开销)
开发难度	最简单 (兼容旧习惯)	简单 (go 关键字)	最难 (需理解借用、Pin、Poll)
代表作	Spring Boot 3.x, Tomcat	K8s, Docker, TiDB	RisingWave, Linkerd, Deno

总结：

1. 如果你在做传统的企业级业务（Spring 生态）： 闭眼升级 JDK 21。它让你用最舒适的方式，获得了以前要写复杂异步代码才能换来的 QPS。

2. 如果你在做高并发微服务、云原生组件： Go 依然是首选。它的开发效率和并发性能达到了完美的平衡。

3. 如果你在挑战极限（数据库底层、存储引擎、高性能网关）： Rust 是唯一的答案。它是那些“爆火”的基础设施类软件背后的秘密武器，因为它能提供不带 GC 抖动的极致性能。