Why does a blocking call inside one asyncio coroutine freeze the whole event loop?

**One thread, one loop, no preemption.** The reason is structural rather than subtle. An asyncio event loop runs on exactly one thread and repeats a fixed iteration: run the callbacks that are already ready, ask the selector which registered file descriptors are readable or writable (blocking at most until the next timer deadline), queue the callbacks those wake, and run the timer callbacks whose deadline has passed against the loop's monotonic clock. Coroutines participate through Tasks: a Task calls into the coroutine, the coroutine runs ordinary Python until it hits an `await` that suspends, and control returns to the loop with a note about what should resume it. Nothing in that picture can interrupt running Python code. There is no scheduler thread, no timer signal, no quantum. The loop regains control only when the currently running coroutine hands it back. So a synchronous call — `time.sleep(2)`, a blocking socket `recv`, a large image resize, a synchronous database driver, a `json.loads` on a huge payload — does not "block that coroutine". It blocks the crank. The selector is not polled; sockets that became readable stay unread; timers whose deadline passed are not noticed; `asyncio.sleep(0.05)` in some other task returns after 2.05 seconds. A worked case makes the shape obvious. An image-thumbnail worker consumes jobs and, inside `async def handle(job)`, calls a synchronous resize that takes about 300 ms. Under a light load nothing looks wrong. Under a hundred concurrent jobs, the service's 92nd-percentile budget blows out first, because delay is additive across everything in flight: while job A resizes, jobs B through Z are frozen, and each of them will in turn freeze the rest. Mean latency lies about this, because it averages the waiting into the many jobs that happened to sit near the front of a queue; the tail tells the truth. Two secondary symptoms confirm the diagnosis: timeouts that fire well past their deadline (timers are checked once per iteration, so a 300 ms stall shifts every deadline by up to 300 ms), and heartbeats or health checks that go quiet in bursts rather than degrading smoothly. ```python import asyncio, time async def resize(): time.sleep(0.3) # synchronous: the loop is stuck here async def heartbeat(): for _ in range(3): await asyncio.sleep(0.05) print("beat") # all three arrive after the 300 ms stall async def main(): await asyncio.gather(resize(), heartbeat()) asyncio.run(main()) ``` **`async def` grants nothing by itself.** Marking a function `async def` only makes it a coroutine function; it does not make its body concurrent, and `await` does not make a synchronous callee non-blocking. `await some_sync_wrapper()` still runs that code to completion on the loop thread. The only thing that helps is the code actually suspending. **Where suspension really happens.** Only awaits that are not already resolved give the loop a turn. Awaiting a future that is already done, or a coroutine that returns without suspending, keeps the thread the whole way. For a long CPU-bound stretch you can insert `await asyncio.sleep(0)` between chunks — a documented yield that reschedules the current task at the back of the ready queue and lets one loop iteration happen. That is a mitigation, not a cure: it converts one long stall into many short ones, and the total CPU still competes with everything else on that thread. Real CPU-bound work belongs off the loop thread — handed to a worker thread or a separate process — and pure waiting belongs in an async-aware client rather than a blocking one. **Free threading does not change this.** The free-threaded build, officially supported in 3.14 (PEP 779), removes the interpreter-wide lock so *threads* can run Python in parallel. A single event loop still drives its own tasks sequentially on its own thread; a coroutine has no thread of its own to be parallel with. Getting parallelism means several loops on several threads, or work moved off the loop, not a different build flag. The practical rule to state in an interview: **inside a coroutine, every line between two awaits is latency you are adding to every other task on that loop.** Budget those stretches the way you would budget time inside a lock.