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

译者注：

原文链接：https://pkolaczk.github.io/memory-consumption-of-async/
Github项目地址：https://github.com/pkolaczk/async-runtimes-benchmarks

正文

在这篇博客文章中，我深入探讨了异步和多线程编程在内存消耗方面的比较，跨足了如Rust、Go、Java、C#、Python、Node.js 和 Elixir等流行语言。

不久前，我不得不对几个计算机程序进行性能比较，这些程序旨在处理大量的网络连接。我发现那些程序在内存消耗方面有巨大的差异，甚至超过20倍。有些程序在10000个连接中仅消耗了略高于100MB的内存，但另一些程序却达到了接近3GB。不幸的是，这些程序相当复杂，功能也不尽相同，因此很难直接进行比较并得出有意义的结论，因为这不是一个典型的苹果到苹果的比较。这促使我想出了创建一个综合性基准测试的想法。

基准测试

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

启动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，一个使用tokio，另一个使用async-std。以下是使用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语言中，goroutine是实现并发的基本构建块。我们不需要分开等待它们，而是使用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提供了虚拟线程的预览，这是一个类似于goroutine的概念。因此，我创建了两个版本的基准测试。我也很好奇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#

与Rust类似，C#对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)

测试环境

硬件: Intel(R) Xeon(R) CPU E3-1505M v6 @ 3.00GHz
操作系统: Ubuntu 22.04 LTS, Linux p5520 5.15.0-72-generic
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

所有程序在可用的情况下都使用发布模式（release mode）进行运行。其他选项保持为默认设置。

结果

最小内存占用

让我们从一些小的任务开始。因为某些运行时需要为自己分配一些内存，所以我们首先只启动一个任务。

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

我们可以看到，这些程序确实分为两组。Go和Rust程序，静态编译为本地可执行文件，需要很少的内存。其他在托管平台上运行或通过解释器消耗更多内存的程序，尽管在这种情况下Python表现得相当好。这两组之间的内存消耗差距大约有一个数量级。

让我感到惊讶的是，.NET某种程度上具有最差的内存占用，但我猜这可以通过某些设置进行调整。如果有任何技巧，请在评论中告诉我。在调试模式和发布模式之间，我没有看到太大的区别。

10k 任务

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

这里有一些意外发现！大家可能都预计线程将成为这个基准测试的大输家。这对于Java线程确实如此，实际上它们消耗了将近250MB的内存。但是从Rust中使用的原生Linux线程似乎足够轻量级，在10000个线程时，内存消耗仍然低于许多其他运行时的空闲内存消耗。异步任务或虚拟（绿色）线程可能比原生线程更轻，但我们在只有10000个任务时看不到这种优势。我们需要更多的任务。

另一个意外之处是Go。Goroutines应该非常轻量，但实际上，它们消耗的内存超过了Rust线程所需的50%。坦率地说，我本以为Go的优势会更大。因此，我认为在10000个并发任务中，线程仍然是相当有竞争力的替代方案。Linux内核在这方面肯定做得很好。

Go也失去了它在上一个基准测试中相对于Rust异步所占据的微小优势，现在它比最好的Rust程序消耗的内存多出6倍以上。它还被Python超越。

最后一个意外之处是，在10000个任务时，.NET的内存消耗并没有从空闲内存使用中显著增加。可能它只是使用了预分配的内存。或者它的空闲内存使用如此高，10000个任务太少以至于不重要。

100k 任务

我无法在我的系统上启动100,000个线程，所以线程基准测试必须被排除。可能这可以通过某种方式调整系统设置来实现，但尝试了一个小时后，我放弃了。所以在100,000个任务时，你可能不想使用线程。

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

而Linux .NET可能有作弊，因为它的内存使用仍然没有增加。

标签：tasks,并发,任务,线程,内存,Go,100,Rust
From： https://www.cnblogs.com/InCerry/p/memory-consumption-of-async.html