2024年各编程语言运行100万个并发任务需要多少内存？

wowoqu

你还记得2023年那篇比较各种流行编程语言异步编程内存消耗比较的文章吗？
现在是2024年底，我很好奇在一年时间里，随着各种语言的最新版本发布，情况有什么变化。
让我们再次进行基准测试，看看结果！
基准

用于基准测试的程序与去年相同：

让我们启动 N 个并发任务，每个任务等待 10 秒，然后在所有任务完成后程序退出。任务的数量由命令行参数控制。

这次，让我们专注于协程而不是多线程。
所有基准代码可以在async-runtimes-benchmarks-2024访问。
什么是协程？

协程是计算机程序的一种组件，能够暂停和恢复执行。这使得它比传统的线程更灵活，特别适合用于处理需要协作的多任务操作，比如实现任务协作、异常处理、事件循环、迭代器、无限列表和数据管道等功能。

Rust

我用 Rust 创建了 2 个程序。一个使用tokio：
use std::env;use tokio::time::{sleep, Duration};#[tokio::main]async fn main() {    let args: Vec<String> = env::args().collect();    let num_tasks = args[1].parse::<i32>().unwrap();    let mut tasks = Vec::new();    for _ in 0..num_tasks {        tasks.push(sleep(Duration::from_secs(10)));    }    futures::future::join_all(tasks).await;}而另一个使用async_std：
use std::env;use async_std::task;use futures::future::join_all;use std::time::Duration;#[async_std::main]async fn main() {    let args: Vec<String> = env::args().collect();    let num_tasks = args[1].parse::<usize>().unwrap();    let mut tasks = Vec::new();    for _ in 0..num_tasks {        tasks.push(task::sleep(Duration::from_secs(10)));    }    join_all(tasks).await;}两者都是 Rust 中常用的异步运行时。
C#

C#，与 Rust 类似，对 async/await 提供了一流的支持：
int numTasks = int.Parse(args[0]);List<Task> tasks = new List<Task>();for (int i = 0; i < numTasks; i++){    tasks.Add(Task.Delay(TimeSpan.FromSeconds(10)));}await Task.WhenAll(tasks);自 .NET 7 起，.NET 还提供了 NativeAOT 编译，它将代码直接编译为最终的二进制文件，因此不再需要 VM 来运行托管代码。因此，我们也添加了 NativeAOT 的基准测试。
NodeJS

NodeJS 也是如此：
const util = require('util');const delay = util.promisify(setTimeout);async function runTasks(numTasks) {  const tasks = [];  for (let i = 0; i < numTasks; i++) {    tasks.push(delay(10000));  }  await Promise.all(tasks);}const numTasks = parseInt(process.argv[2]);runTasks(numTasks);Python

还有 Python：
import asyncioimport sysasync def main(num_tasks):    tasks = []    for task_id in range(num_tasks):        tasks.append(asyncio.sleep(10))    await asyncio.gather(*tasks)if __name__ == "__main__":    num_tasks = int(sys.argv[1])    asyncio.run(main(num_tasks))Go

在 Go 语言中，goroutine 是实现并发的关键。我们不需要逐个等待 goroutine ，而是通过 WaitGroup 来统一管理：
package mainimport (    "fmt"    "os"    "strconv"    "sync"    "time")func main() {    numRoutines, _ := strconv.Atoi(os.Args[1])    var wg sync.WaitGroup    for i := 0; i < numRoutines; i++ {        wg.Add(1)        go func() {            defer wg.Done()            time.Sleep(10 * time.Second)        }()    }    wg.Wait()}Java

自 JDK 21 起，Java 提供了虚拟线程，这与协程的概念相似：
import java.time.Duration;import java.util.ArrayList;import java.util.List;public class VirtualThreads {    public static void main(String[] args) throws InterruptedException {            int numTasks = Integer.parseInt(args[0]);        List<Thread> threads = new ArrayList<>();        for (int i = 0; i < numTasks; i++) {            Thread thread = Thread.startVirtualThread(() -> {                try {                    Thread.sleep(Duration.ofSeconds(10));                } catch (InterruptedException e) {                    // Handle exception                }            });            threads.add(thread);        }        for (Thread thread : threads) {            thread.join();        }    }}Java有一个新的 JVM 变体叫做 GraalVM。GraalVM 还提供本机镜像，这与.NET 中的 NativeAOT 概念相似。因此，我们也为 GraalVM 添加了基准测试。
测试环境

• 硬件：第 13 代英特尔(R)酷睿(TM) i7-13700K
  
• 操作系统：Debian GNU/Linux 12 (bookworm)
  
• Rust: 1.82.0
  
• .NET: 9.0.100
  
• Go: 1.23.3
  
• Java: openjdk 23.0.1 build 23.0.1+11-39
  
• Java (GraalVM): java 23.0.1 build 23.0.1+11-jvmci-b01
  
• NodeJS: v23.2.0
  
• Python: 3.13.0
  

如果可用，所有程序都使用发布模式启动，并且由于我们的测试环境中没有 libicu，国际化和全球化支持被禁用。
结果

最小内存占用

让我们从小规模开始，因为某些运行时本身就需要一些内存，我们先只启动一个任务。

我们可以看到 Rust、C#(NativeAOT) 和 Go 达到了类似的结果，因为它们都被静态编译成原生二进制文件，需要很少的内存。Java(GraalVM native-image) 也表现不错，但比其他静态编译的程序多用了一点内存。其他在托管平台上运行或通过解释器运行的程序消耗更多内存。
在这种情况下，Go似乎有最小的内存占用。
Java 使用 GraalVM 的结果有点出人意料，因为它比 OpenJDK 的 Java 消耗更多内存，但我猜这可以通过一些设置来调优。
1万个任务


这里有一些惊喜！两个 Rust 基准测试都取得了非常好的结果：即使后台运行着1万个任务，它们使用的内存也很少，与最小内存占用相比没有增长太多！C#(NativeAOT) 紧随其后，只使用了约 10MB 内存。我们需要更多任务来给它们施加压力！
Go 的内存消耗显著增加。goroutines 应该是非常轻量级的，但实际上它们消耗的 RAM 比 Rust 多得多。在这种情况下，Java(GraalVM native image) 中的虚拟线程似乎比 Go 中的 Goroutines 更轻量级。令我惊讶的是，Go 和Java(GraalVM native image) 这两个静态编译成原生二进制文件的程序，比运行在VM上的C#消耗更多RAM！
10万个任务


在我们将任务数量增加到 10 万后，所有语言的内存消耗开始显著增长。
Rust 和 C# 在这种情况下都表现得很好。一个大惊喜是 C#(NativeAOT) 甚至比 Rust 消耗更少的 RAM ，击败了所有其他语言。非常令人印象深刻！
在这一点上，Go 程序不仅被 Rust 击败，还被 Java（除了在 GraalVM 上运行的那个）、C# 和 NodeJS 击败。
100万个任务

现在让我们走个极端。

最终，C#毫无疑问地击败了所有其他语言；它非常有竞争力，真的成为了一个怪物。正如预期的那样，Rust在内存效率方面继续表现出色。
Go 与其他语言的差距进一步扩大。现在 Go 比冠军多消耗13倍以上的内存。它也比 Java 多消耗2倍以上，这与 JVM 是内存大户而 Go 轻量级的普遍认知相矛盾。
总结

正如我们观察到的，大量并发任务即使不执行复杂操作也会消耗大量内存。不同的语言运行时有不同的权衡，有些对少量任务来说轻量高效，但在处理数十万个任务时扩展性较差。
自去年以来，很多事情都发生了变化。通过对最新编译器和运行时的基准测试结果，我们看到 .NET 有了巨大的改进，使用 NativeAOT 的 .NET 真的能与 Rust 竞争。用 GraalVM 构建的 Java 原生镜像在内存效率方面也表现出色。然而，Go 的 goroutines 在资源消耗方面继续表现不佳。
版权信息

原作者：hez2010
译者：InCerry
原文链接：https://hez2010.github.io/async-runtimes-benchmarks-2024/