Come funziona async/await con asyncio?

Question

Accepted Answer

**asyncio** is Python's framework for **concurrent I/O** using `async`/`await`. It runs many I/O operations cooperatively on a **single thread** via an event loop — efficient for high-concurrency I/O-bound work (network calls, web servers) without the overhead of threads.

## Definire ed eseguire coroutine

```python
import asyncio

async def fetch_data(id):       # an async function = a coroutine
    print(f"start {id}")
    await asyncio.sleep(1)       # await a non-blocking I/O operation (yields control)
    print(f"done {id}")
    return id

asyncio.run(fetch_data(1))       # run a coroutine from sync code
```

An `async def` function is a **coroutine**; `await` suspends it at an I/O point, letting the event loop run *other* coroutines meanwhile — then resumes when the awaited operation completes.

## Il vantaggio chiave: I/O concorrente

```python
# ❌ sequential — total time ≈ 3 seconds
async def slow():
    await fetch_data(1)   # wait 1s
    await fetch_data(2)   # then wait 1s
    await fetch_data(3)   # then wait 1s

# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
    await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
```

`asyncio.gather` runs coroutines **concurrently** — while one awaits I/O, the others proceed. Three 1-second waits overlap into ~1 second total. This is the core value: overlapping many I/O waits on one thread.

## Come differisce dai thread

```text
Threading:  OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio:    single thread, COOPERATIVE — coroutines yield at `await` points
            → lighter weight (handle thousands of connections), no thread overhead,
              but one CPU-heavy coroutine blocks everything (no preemption)
```

## La regola cardinale: non bloccare l'event loop

```python
async def bad():
    time.sleep(5)              # ❌ BLOCKS the whole event loop (sync sleep)
    result = heavy_compute()    # ❌ CPU work freezes all coroutines

async def good():
    await asyncio.sleep(5)      # ✅ non-blocking
    # offload CPU work to a thread/process pool
    await loop.run_in_executor(None, heavy_compute)
```

Because it's cooperative and single-threaded, any blocking/CPU-heavy call freezes *all* coroutines. Use `await`-able async APIs, and offload blocking/CPU work to an executor.

## Dove asyncio eccelle

```text
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
  websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
```

## Perché è importante

asyncio is the modern approach to **high-concurrency I/O** in Python, powering frameworks like FastAPI and enabling efficient handling of thousands of simultaneous connections on a single thread — far lighter than thread-per-connection.

Understanding coroutines, `await`, concurrent execution with `gather`, and especially the **cardinal rule** (never block the event loop; offload CPU/blocking work) is essential for writing performant async Python.

Knowing when it fits (I/O-bound concurrency) versus when it doesn't (CPU-bound → multiprocessing) is key to using it effectively.