
A lot of people assume that turning functions into async def makes an app faster. Usually it doesn't, and sometimes it makes things slower.
Async doesn't speed up a single line of code. It lets one thread do other work while a task is waiting. If nothing is waiting, there's nothing to gain.
What async def actually gives you
Calling an
async deffunction returns a coroutine object. The body doesn't run yet.Coroutines run on an event loop: one thread, tasks taking turns.
A task only gives up its turn at an
awaitthat really suspends, like a network call, a sleep or a queue read.
The rule: async is efficient waiting, not faster computing.
Before reaching for it, ask what your code is actually slow at:
flowchart TD
A["My code is slow. Should I use async?"] --> B{"Mostly waiting on network or disk?"}
B -- No --> C["CPU-bound: use processes or faster code"]
B -- Yes --> D{"Many things to wait on at once?"}
D -- No --> E["Plain sync code is fine"]
D -- Yes --> F{"Is there an async library for it?"}
F -- Yes --> G["asyncio with gather or TaskGroup"]
F -- No --> H["asyncio.to_thread around the blocking call"]Note: All timings below come from a single-core Linux box running Python 3.12. Your numbers will differ, but the patterns won't.
Pitfall 1: Forgetting to await
import asyncio
async def fetch_user():
await asyncio.sleep(0.1)
return {"id": 1}
async def main():
fetch_user() # forgot await
print("done")
asyncio.run(main())main.py:8: RuntimeWarning: coroutine 'fetch_user' was never awaited
fetch_user() # forgot await
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
doneThe call created a coroutine and threw it away. Nothing ran. Use user = await fetch_user(), or asyncio.create_task(fetch_user()) if you want it to run in the background.
Pitfall 2: Awaiting one thing at a time
This is the most common reason async code isn't faster. Each await finishes before the next line starts:
import asyncio, time
async def call(n):
await asyncio.sleep(1) # pretend this is a network request
return n
async def sequential():
return [await call(i) for i in range(3)]
async def concurrent():
return await asyncio.gather(*(call(i) for i in range(3)))
for fn in (sequential, concurrent):
start = time.perf_counter()
asyncio.run(fn())
print(f"{fn.__name__}: {time.perf_counter() - start:.2f}s")sequential: 3.00s
concurrent: 1.00sThree one-second waits took three seconds one after another and one second together. On Python 3.11+, asyncio.TaskGroup does the same job with better error handling (see Pitfall 6).
Pitfall 3: Blocking the event loop
time.sleep(), requests.get(), most sync database drivers and heavy file reads all block the entire loop. Every other task freezes until they return.
Here's a heartbeat task that ticks every half second, while a blocking call runs:
import asyncio, time
async def heartbeat():
start = time.perf_counter()
while True:
print(f"tick {time.perf_counter() - start:.1f}s")
await asyncio.sleep(0.5)
async def main():
hb = asyncio.create_task(heartbeat())
await asyncio.sleep(0.1)
time.sleep(2) # blocking call inside async code
await asyncio.sleep(0.6)
hb.cancel()
asyncio.run(main())tick 0.0s
tick 2.1s
tick 2.6sThe heartbeat went silent for two seconds. In a web server, that's every other request hanging.
Fixes:
Use an async library (
httpx,aiohttp,asyncpg) andawait asyncio.sleep().If a library has no async version, run it in a thread:
await asyncio.to_thread(blocking_fn, arg)(Python 3.9+). I swappedtime.sleep(2)forawait asyncio.to_thread(time.sleep, 2)and the heartbeat ticked normally.
Finding the culprit: run your app in asyncio debug mode. It logs any step that holds the loop for more than 100 ms.
import asyncio, time
async def handler():
time.sleep(0.5) # blocking call hiding in async code
asyncio.run(handler(), debug=True)Executing <Task finished name='Task-1' coro=<handler() done, ...> took 0.500 secondsFastAPI note:
async defendpoints run directly on the event loop, so a blocking call inside one freezes every request. Plaindefendpoints are run in a thread pool instead. If you must call blocking code, either usedefor wrap the call into_thread.
Pitfall 4: CPU-bound work
Wrapping CPU work in async def changes nothing. There's no await that waits, so the function just runs start to finish and nothing else gets a turn.
import asyncio, time
from concurrent.futures import ProcessPoolExecutor
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
async def fib_async(n): # async, but still CPU-bound
return fib(n)
async def main():
loop = asyncio.get_running_loop()
start = time.perf_counter()
[fib(33) for _ in range(3)]
print(f"plain loop: {time.perf_counter() - start:.2f}s")
start = time.perf_counter()
await asyncio.gather(*(fib_async(33) for _ in range(3)))
print(f"async def + gather: {time.perf_counter() - start:.2f}s")
with ProcessPoolExecutor() as pool:
start = time.perf_counter()
await asyncio.gather(*(loop.run_in_executor(pool, fib, 33) for _ in range(3)))
print(f"process pool: {time.perf_counter() - start:.2f}s")
if __name__ == "__main__":
asyncio.run(main())plain loop: 1.20s
async def + gather: 1.22s
process pool: 1.14sAll three took about the same. The async version is no faster than the plain loop. And while it ran, a heartbeat task I added ticked once in about a second of work, so the loop was effectively frozen.
The process pool wasn't faster either, because my test machine has a single core. What it did was keep the loop responsive: the heartbeat kept ticking every 0.2 seconds. On a multi-core machine, the jobs also run in parallel.
Threads won't help for pure-Python CPU work in standard CPython builds, because the GIL lets only one thread run Python code at a time. Use processes, or move the hot path to native code (NumPy, Rust, C extensions).
Pitfall 5: Unlimited concurrency
gather on 10,000 coroutines starts 10,000 requests at once. That's a quick way to hit rate limits, exhaust connection pools or run out of file descriptors. Cap it with a semaphore:
import asyncio
in_flight = peak = 0
async def fetch(i, limit):
global in_flight, peak
async with limit:
in_flight += 1
peak = max(peak, in_flight)
await asyncio.sleep(0.05) # pretend API call
in_flight -= 1
async def main():
limit = asyncio.Semaphore(20) # at most 20 calls in flight
await asyncio.gather(*(fetch(i, limit) for i in range(1000)))
print("peak in flight:", peak)
asyncio.run(main())peak in flight: 20Without the semaphore, the peak was 1,000.
Pitfall 6: Tasks that fail quietly or vanish
gather doesn't cancel the others when one fails. The exception reaches you, but the remaining tasks keep running in the background. TaskGroup (3.11+) cancels them:
import asyncio
async def boom():
await asyncio.sleep(0.1)
raise ValueError("boom")
async def slow(log):
try:
await asyncio.sleep(0.3)
log.append("slow finished")
except asyncio.CancelledError:
log.append("slow cancelled")
raise
async def main():
for name in ("gather", "TaskGroup"):
log = []
try:
if name == "gather":
await asyncio.gather(boom(), slow(log))
else:
async with asyncio.TaskGroup() as tg:
tg.create_task(boom())
tg.create_task(slow(log))
except* ValueError:
pass
await asyncio.sleep(0.4)
print(f"{name:9s} -> {log}")
asyncio.run(main())gather -> ['slow finished']
TaskGroup -> ['slow cancelled']Fire-and-forget tasks can disappear. The event loop only holds a weak reference to tasks, so a task nobody references can be garbage collected before it finishes. The asyncio docs recommend keeping your own reference:
background_tasks = set()
def fire_and_forget(coro):
task = asyncio.create_task(coro)
background_tasks.add(task)
task.add_done_callback(background_tasks.discard)
return taskAsync isn't free
Awaiting a coroutine is cheap. Turning each one into a task is not:
Test | Time |
|---|---|
1,000,000 plain function calls | about 0.07s |
1,000,000 awaited coroutines | about 0.10s |
100,000 coroutines through | about 0.66s |
If you're making a handful of calls, or the work finishes instantly, plain sync code is simpler and often faster. Don't spawn a task per tiny operation.
Quick reference
Symptom | Likely cause | Fix |
|---|---|---|
"coroutine was never awaited" | Missing | Add |
Async is as slow as sync | Awaiting one at a time |
|
Everything freezes during one call | Blocking call in async code | Async library or |
High CPU, no speedup | CPU-bound work | Process pool |
Rate limits, "too many open files" | Unbounded concurrency |
|
One failure, others keep running |
|
|
Background task never finishes | Task garbage collected | Keep a reference |
Wrap-up
Async is a tool for overlapping waits. Before you add async def for speed, check three things: is the code mostly waiting, are you awaiting things concurrently, and is anything inside blocking the loop? If the answer to the first is no, async won't help.
Comments(0)
Join the discussion by logging into your account.
No comments yet. Be the first to comment!