How Much Memory for 1,000,000 Threads in 7 Languages | Go, Rust, C#, Elixir, Java, Node, Python

Summary

This blog post explores the memory consumption of handling a million concurrent tasks across various programming languages, including Rust, Go, Java, C#, Python, Node.js, and Elixir. The author compares asynchronous and multi-thread programs, noting significant differences in memory usage. Through synthetic benchmarks, the author tests each language's capability to launch and wait for 10 seconds on tasks, observing that Rust with Tokio async runtime and Go's goroutines performed well with low memory footprint. Surprisingly, C# managed to compete with Rust, while Node.js and Elixir consumed more memory. The author suggests that real-world tests involving tasks like websocket connections would provide a more accurate representation of language performance.

Takeaways

• 🧠 The script discusses a benchmark comparing memory consumption between asynchronous and multi-thread programs in various programming languages such as Rust, Go, Java, C#, Python, Node.js, and Elixir.
• 🔍 The author highlights a significant difference in memory consumption among different programs, with some consuming over 100 megabytes and others reaching almost three gigabytes.
• 📈 A synthetic benchmark was created to test the performance of programs handling a large number of network connections, with the number of tasks controlled by a command-line argument.
• 🤖 Rust was tested with three different programs using traditional threads, async with Tokio, and async with async-std, showing the language's capabilities with different threading models.
• 🐹 Go routines were used to demonstrate Go's ability to handle concurrency, with the use of a wait group to manage the completion of tasks.
• 🌟 Java's introduction of virtual threads in JDK 21 was noted as a significant step forward, bringing it closer to the capabilities of Go routines.
• 🚀 C# was shown to have first-class support for async-await, which is similar to managed environments found in other languages.
• 🐍 Node.js was pointed out as having a high memory footprint, especially when handling a large number of connections, due to its event-driven, non-blocking I/O model.
• 🐍 Python demonstrated surprisingly low memory consumption, especially when using asyncio, which was unexpected compared to other managed runtimes.
• 🔑 The importance of considering factors such as task launch time and communication speeds, in addition to memory consumption, was emphasized for a comprehensive performance evaluation.
• 🔍 The author suggests that the benchmark should be expanded to include more realistic use cases, such as handling websocket connections or open TCP connections, to better reflect real-world programming challenges.

Q & A

What is the main topic of the blog post discussed in the transcript?

The main topic of the blog post is a comparison of memory consumption between asynchronous and multi-thread programs across various popular programming languages when handling a large number of concurrent tasks.

Why did the author create a synthetic benchmark for the comparison?

The author created a synthetic benchmark because the existing computer programs they needed to compare were complex and differed in features, making it difficult to draw meaningful conclusions from a direct comparison.

What programming languages were included in the memory consumption comparison?

The programming languages included in the comparison were Rust, Go, Java, C#, Python, Node.js, and Elixir.

What is the significance of the GitHub repository mentioned in the transcript?

The GitHub repository mentioned is where the author has shared the synthetic benchmark programs written in various languages, allowing others to contribute and test the performance of their own languages.

What was the author's observation regarding Node.js in terms of memory consumption?

The author observed that Node.js has a high memory consumption, especially when handling a large number of connections, with some programs consuming almost three gigabytes of memory.

What is the difference between traditional threads and async/green threads as mentioned in the Rust programs?

Traditional threads in Rust are actual OS threads, while async/green threads are managed by the runtime and are lighter in terms of system resources, as seen with async implementations using Tokyo and async-std.

What is the concept of 'virtual threads' introduced in Java JDK 21?

Virtual threads in Java JDK 21 are a feature that provides a similar concept to Go routines, allowing for a large number of lightweight threads that are managed by the JVM, rather than OS threads.

What is the author's opinion on the memory consumption of .NET (C#) in the benchmark?

The author was surprised that .NET (C#) had the worst memory footprint in the benchmark, especially considering it requires a significant amount of memory even when idle.

How did the author find Python's performance in the memory consumption benchmark?

The author found Python's performance surprising, as it fared well in terms of memory consumption, using only half the memory of Java or Node.js.

What was the author's final observation on the memory consumption of concurrent tasks?

The author observed that a high number of concurrent tasks can consume a significant amount of memory, and that runtimes with high initial overhead, like C#, can handle high workloads more effectively.