Memory Overhead Comparison

The numbers, ranked

The factor between "OS thread" and "lightweight" is 100-1000x. That's the difference between 10K and 1M concurrent units on the same hardware.

Where memory overhead bites

The hidden cost: ThreadLocal

50 ThreadLocals in framework × 1M virtual threads × 100B avg ≈ 5GB

Java's virtual thread era exposed this. ThreadLocal was fine at thousands of threads; with millions, the per-thread state dwarfs the thread itself. Hence Java 21's ScopedValue.

How to measure

• Linux: ps -o rss,vsz <pid>, physical (RSS) and virtual (VSZ) memory.
• Java: jcmd <pid> VM.native_memory summary, breakdown by thread, GC, code cache.
• Go: runtime.MemStats, heap, stacks, GC overhead.
• Per-thread: pmap -x <pid> shows mapped regions with sizes.

Reproduce the numbers locally

Spawn N concurrent units that all park, snapshot RSS, divide. Useful for sanity-checking the table on local hardware.

// Goroutine memory cost. Run: go run thread_mem.go
package main

import (
    "fmt"
    "runtime"
    "sync"
)

func main() {
    const N = 100_000
    var wg sync.WaitGroup
    block := make(chan struct{})

    var m1, m2 runtime.MemStats
    runtime.ReadMemStats(&m1)

    wg.Add(N)
    for i := 0; i < N; i++ {
        go func() { defer wg.Done(); <-block }()
    }

    runtime.ReadMemStats(&m2)
    delta := float64(m2.StackInuse-m1.StackInuse) / float64(N)
    fmt.Printf("%d goroutines parked, ~%.0f bytes stack each\n", N, delta)

    close(block)
    wg.Wait()
    // Typical output: 100000 goroutines parked, ~2200 bytes stack each
}

// Virtual thread memory cost. Run on Java 21+
import java.util.concurrent.CountDownLatch;

public class VThreadMem {
    public static void main(String[] args) throws Exception {
        int n = 100_000;
        CountDownLatch park = new CountDownLatch(1);
        Runtime.getRuntime().gc();
        long before = used();
        for (int i = 0; i < n; i++) {
            Thread.startVirtualThread(() -> {
                try { park.await(); } catch (InterruptedException e) {}
            });
        }
        Thread.sleep(500);
        long after = used();
        System.out.printf("%d virtual threads, ~%d bytes each%n",
                          n, (after - before) / n);
        park.countDown();
    }
    static long used() {
        Runtime r = Runtime.getRuntime();
        return r.totalMemory() - r.freeMemory();
    }
}
// Typical: ~3000-5000 bytes per parked virtual thread

# Asyncio task memory cost
import asyncio, tracemalloc

async def park(ev): await ev.wait()

async def main():
    n = 100_000
    ev = asyncio.Event()
    tracemalloc.start()
    snap1 = tracemalloc.take_snapshot()
    tasks = [asyncio.create_task(park(ev)) for _ in range(n)]
    await asyncio.sleep(0.1)
    snap2 = tracemalloc.take_snapshot()
    diff = sum(s.size for s in snap2.statistics("filename")) - \
           sum(s.size for s in snap1.statistics("filename"))
    print(f"{n} tasks, ~{diff//n} bytes each")
    ev.set()
    await asyncio.gather(*tasks)

asyncio.run(main())
# Typical: ~1500-2500 bytes per parked task

For OS threads, the cheapest way is to use the same Java program with Thread.ofPlatform().start(...); this shows ~1MB per thread because the JVM allocates a 1MB stack whether or not it gets touched. Spawning 100K platform threads will OOM most laptops.