在这篇博文中，我深入研究了Rust，Go，Java，C#，Python，Node.js 和 Elixir等流行语言的异步和多线程编程之间的内存消耗比较。

前段时间，我不得不比较一些旨在处理大量网络连接的计算机程序的性能。我看到这些程序的内存消耗差异很大，甚至超过了 20 倍。一些程序消耗略高于 100 MB，但其他程序在 3k 连接时达到近 10 GB。不幸的是，这些程序非常复杂，并且在功能上也有所不同，因此很难直接比较它们并得出一些有意义的结论，因为这不是一个苹果对苹果的比较。这让我想到了一个创建综合基准的想法。

基准

我用各种编程语言创建了以下程序：

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

在 ChatGPT 的帮助下，我可以在几分钟内编写这样的程序，即使是我不是每天都使用的编程语言。为了您的方便，所有基准代码都可以在 GitHub 上找到。

Rust

我在 Rust 中创建了 3 个程序。第一个使用传统线程。这是它的核心代码：

let mut handles = Vec::new();
for _ in 0..num_threads {
    let handle = thread::spawn(|| {
        thread::sleep(Duration::from_secs(10));
    });
    handles.push(handle);
}
for handle in handles {
    handle.join().unwrap();
}

另外两个版本使用异步，一个是 async-std, 另一个是 tokio. 这是 tokio 版本的代码：

let mut tasks = Vec::new();
for _ in 0..num_tasks {
    tasks.push(task::spawn(async {
        time::sleep(Duration::from_secs(10)).await;
    }));
}
for task in tasks {
    task.await.unwrap();
}

async-std 版本非常相似，所以我不会在这里引用它。

Go

在 Go 中，goroutines 是并发的构建块。我们不会单独等待它们，而是使用 WaitGroup

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

Java传统上使用线程，但JDK 21提供了虚拟线程的预览，这与goroutines 的概念类似。因此，我创建了基准测试的两个版本。我也很好奇Java线程与Rust的线程相比如何。

List<Thread> threads = new ArrayList<>();
for (int i = 0; i < numTasks; i++) {
    Thread thread = new Thread(() -> {
        try {
            Thread.sleep(Duration.ofSeconds(10));
        } catch (InterruptedException e) {
        }
    });
    thread.start();
    threads.add(thread);
}
for (Thread thread : threads) {
    thread.join();
}

这是带有虚拟线程的版本。请注意它是多么相似！几乎一模一样！

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) {
        }
    });
    threads.add(thread);
}
for (Thread thread : threads) {
    thread.join();
}

C#

C#，类似于Rust，对async/await有一流的支持：

List<Task> tasks = new List<Task>();
for (int i = 0; i < numTasks; i++)
{
    Task task = Task.Run(async () =>
    {
        await Task.Delay(TimeSpan.FromSeconds(10));
    });
    tasks.Add(task);
}
await Task.WhenAll(tasks);

Node.JS

Node.JS也是如此：

const delay = util.promisify(setTimeout);
const tasks = [];

for (let i = 0; i < numTasks; i++) {
    tasks.push(delay(10000);
}

await Promise.all(tasks);

Python

Python 在 3.5 中添加了 async/await，所以我们可以编写：

async def perform_task():
    await asyncio.sleep(10)


tasks = []

for task_id in range(num_tasks):
    task = asyncio.create_task(perform_task())
    tasks.append(task)

await asyncio.gather(*tasks)

Elixir

Elixir也以其异步功能而闻名：

tasks =
    for _ <- 1..num_tasks do
        Task.async(fn ->
            :timer.sleep(10000)
        end)
    end

Task.await_many(tasks, :infinity)

测试环境

硬件：英特尔® 至强® CPU E3-1505M v6 @ 3.00GHz
操作系统： Ubuntu 22.04 LTS， Linux 5.15.0-72
Rust: 1.69
Go：1.18.1
Java：OpenJDK “21-ea” build 21-ea+22-1890
.NET： 6.0.116
Node.JS：v12.22.9
Python：3.10.6
Elixir： Erlang/OTP 24 erts-12.2.1， Elixir 1.12.2

所有程序都使用发布模式（如果可用）启动。其他选项保留为默认值。

结果

最小占用内存

让我们从小事做起。由于某些运行时本身需要一些内存，因此让我们首先只启动一个任务。

图例.1：启动一个任务所需的峰值内存

我们可以看到肯定有两组程序。Go 和 Rust 程序静态编译为本机二进制文件，需要很少的内存。在托管平台上或通过解释器运行的其他程序消耗更多内存，尽管Python在这种情况下表现非常好。这两组之间的内存消耗差异大约是一个数量级。

令我惊讶的是，.NET 不知何故具有最糟糕的内存足迹，但我想这可以通过一些设置进行调整。如果有任何技巧，请在评论中告诉我。我还没有看到调试模式和发布模式之间的太大区别。

10k 任务

图 2：启动 10，000 个任务所需的峰值内存

这里有一些惊喜！每个人都可能预料到线程会成为这个基准测试的大输家。对于 Java 线程来说也是如此，它确实消耗了近 250 MB 的 RAM。但是从 Rust 使用的原生 Linux 线程似乎足够轻量级，在 10k 线程下，内存消耗仍然低于许多其他运行时的空闲内存消耗。异步任务或虚拟（绿色）线程可能比本机线程轻，但我们不会在仅 10k 个任务中看到这种优势。我们需要更多的任务。

这里的另一个惊喜是 Go。Goroutines 应该是非常轻量级的，但它们实际上消耗了 Rust 线程所需的 50% 以上的 RAM。老实说，我期待更大的有利于Go的差异。因此，我得出结论，在 10k 个并发任务中，线程仍然是一个相当有竞争力的选择。Linux内核肯定在这里做了一些事情。

Go 在之前的基准测试中也失去了它对 Rust 异步的微小优势，现在它消耗的内存比最好的 Rust 程序多 6 倍以上。

最后一个惊喜是，在 10k 个任务中，.NET 的内存消耗并没有因空闲内存使用而显着增加。可能它只是使用预分配的内存。或者它的空闲内存使用率如此之高，以至于 10k 个任务太少而无关紧要。

100k 任务

我无法在我的系统上启动 100，000 个线程，因此必须排除线程基准测试。可能这可以通过更改系统设置以某种方式进行调整，但是在尝试了一个小时后，我放弃了。因此，在 100k 个任务中，您可能不想使用线程。

图 3：启动 100，000 个任务所需的峰值内存

在这一点上，Go程序不仅被Rust击败，还被Java，C#和Node.JS击败。

Linux .NET可能会作弊，因为它的内存使用量仍然没有上升。;)我不得不仔细检查它是否真的启动了正确数量的任务，但确实如此。大约 10 秒后它仍然退出，而且不会阻塞主循环。魔法！干得好，.NET。

100 万个任务

现在让我们更极端一点。

在100万个任务中，~~我们放弃了Elixir ** (SystemLimitError) a system limit has been reached~~ 将参数 --erl '+P 1000000' 添加到 elixir 调用后，它运行良好。

图 4：启动 100 万个任务所需的峰值内存

最后，我们看到 C# 程序的内存消耗增加。但它仍然非常有竞争力。它甚至设法略微击败了其中一个 Rust 运行时！

Go 和其他人之间的距离增加了。现在 Go输给赢家超过12倍。它也输给了Java的2倍以上，这与JVM是内存消耗和Go是轻量级的普遍看法相矛盾。

Rust tokio 仍然无与伦比。在看到它在 100k 任务中的表现后，这并不奇怪。

结语

正如我们所观察到的，大量并发任务会消耗大量内存，即使它们不执行复杂的操作。不同的语言运行时有不同的权衡，有些对于少量任务来说是轻量级和高效的，但对于数十万个任务来说，扩展性很差。相反，具有高初始开销的其他运行时可以毫不费力地处理高工作负载。需要注意的是，并非所有运行时都能够使用默认设置处理大量并发任务。

这种比较只关注内存消耗，而任务启动时间和通信速度等其他因素同样重要。值得注意的是，在 100 万个任务中，我观察到启动任务的开销变得明显，大多数程序需要超过 12 秒才能完成。请继续关注即将到来的基准测试，我将深入探讨其他方面。

目录

运行 100 万个并发任务需要多少内存？

基准