Asyncio vs Threads: I/O Concurrency Lab with Real Numbers

Intro — what this post promises

Asyncio and threads both overlap waiting work. They are not interchangeable: one multiplexes on a single event loop; the other pays thread stacks and the GIL tax when you accidentally do CPU.

This is a hands-on lab with measured numbers:

1. Concurrent sleep — ideal wall ≈ one delay, not N×delay.
2. Delayed localhost TCP echo — where concurrency actually wins.
3. Instant echo — the overhead trap where serial wins.
4. Mixed sleep + slow TCP on one loop vs a thread pool.
5. Pure-Python CPU control — threads do not parallelize it.

Related links:

• 01shoppercove.comProcessPool vs ThreadPool GIL localhost lab
• 02shoppercove.comPipe vs tmpfile IPC localhost lab
• 03shoppercove.comepoll vs select FD_SETSIZE localhost lab
• 04shoppercove.comWhy your average latency graph is lying (p50 / p95 / p99)

Lab honesty (1 Oct 2026 IST): Shared Linux lab box (8 cores, kernel 6.12). Python 3.13.5 asyncio + ThreadPoolExecutor against a 127.0.0.1 echo (instant and 5 ms delayed). No Docker. No GPU. No API keys. Affiliates: 0.

Verdict up front: sleep asyncio ~59× / threads ~44× vs ideal serial; delayed TCP asyncio ~14× vs serial (~2.4× vs threads w32); instant echo concurrent arms lost; pure-Python CPU threads ~0.92×.

What we compared

Related links:

• 01docs.python.orgasyncio — Concurrent code
• 02docs.python.orgconcurrent.futures — ThreadPoolExecutor

Lab topology

Arm A: 64 × sleep(20 ms) — serial vs ThreadPool(64) vs asyncio.gather
Arm B/C: threaded echo on 127.0.0.1 — delay 5 ms vs 0 ms
         client: serial loop | ThreadPool | asyncio.open_connection gather
Arm D: 32×sleep(20 ms) + 32×slow TCP in one gather / one pool
Arm E: 8× pure-Python CPU loops — serial vs ThreadPool(8)

Arm A — concurrent sleep (the textbook win)

n=64, delay=20 ms, ideal serial = 1.280 s.

Both models collapse wall time toward one delay. Asyncio edged threads here: no per-task OS thread.

Arm B — delayed TCP echo (5 ms think time)

n=64 connect-per 64 B echo. Ideal serial wait ≈ 0.32 s (delay alone).

When each request waits on the peer, overlapping waits is the whole game. Asyncio beat the best thread pool by ~2.4× vs w32 on this box (thread-count sweet spot was w16, not “max workers = n”).

Related links:

• 01shoppercove.comUnix Domain Socket vs TCP localhost lab

Arm C — instant echo (the overhead trap)

Same shape, 0 ms server delay, n=200:

Localhost connect+echo is so cheap that thread/task setup loses to a tight serial loop. Concurrency is not free — measure the wait you are overlapping.

Arm D — mixed sleep + slow TCP

32× sleep(20 ms) + 32× delayed TCP:

One event loop (or one pool) overlaps both wait types. This is the “many sockets + timers” shape asyncio is for.

Arm E — pure-Python CPU (GIL control)

8 tasks of tight pure-Python arithmetic:

Threads did not speed this up. For CPU-bound pure Python, use processes (see the GIL pool lab) — not more threads, and not await on hot loops.

Related links:

• 01shoppercove.comProcessPool vs ThreadPool GIL localhost lab

When to pick which

Pitfalls we hit (or avoided)

1. Benchmarking only instant localhost echo — Arm C lies about I/O concurrency value.
2. Assuming more thread workers always help — w16 beat w32/w64 on Arm B.
3. Putting CPU work on the event loop — serializes everything behind it.
4. Treating this as uvloop / Trio / gevent — we measured stdlib asyncio + threads only.
5. Confusing with ProcessPool CPU scaling — different problem; different lab.

Practical checklist

• Name the wait you are overlapping (delay ms, RTT, disk). If wait ≈ 0, concurrency may lose.
• Report wall + RPS + worker/concurrency + serial baseline together.
• Cap thread workers; sweep (8/16/32) instead of workers=n_tasks by habit.
• Keep CPU off the loop; hand it to processes or native extensions that release the GIL.
• Re-run under your real client library — wrappers add their own tax.

Verdict

On this box: concurrent sleep favored asyncio (~59×) over threads (~44×); delayed TCP favored asyncio (~14× vs serial, ~2.4× vs threads w32); instant echo punished both concurrent arms; pure-Python CPU stayed GIL-bound (~0.92× with threads).

Evidence path on the lab box: lab-evidence/28-asyncio-vs-threads/results/. Affiliates: 0.