Kako deluje async/await z asyncio?

Question

Accepted Answer

**asyncio** je Python-ov okvir za **sočasno I/O** z uporabo `async`/`await`. Izvaja več operacij I/O kooperativno na **enem niti** preko zanke dogodkov — učinkovito za delo I/O-bound z visoko sočasnostjo (omrežni klici, spletni strežniki) brez režije niti.

## Definiranje in zagon korutin

```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
```

Funkcija `async def` je **korutina**; `await` jo suspenzira na točki I/O, kar zanki dogodkov omogoči, da med tem izvede *druge* korutine — nato se nadaljuje, ko se pričakovana operacija zaključi.

## Ključna prednost: sočasno I/O

```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` izvaja korutine **sočasno** — medtem ko ena čaka na I/O, druge napredujejo. Tri čakanja na 1 sekundo se prekrivajo v ~1 sekundo skupno. To je jedra vrednost: prekrivanje številnih čakanj I/O na enem niti.

## Kako se razlikuje od niti

```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)
```

## Temeljno pravilo: ne blokiraj zanke dogodkov

```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)
```

Ker je kooperativna in enoniti, vsak blokirajoči/CPU-intenzivni klic zamrzne *vse* korutine. Uporabi `await`-ne async API-je in preloži blokirajoče/CPU delo na izvršilec.

## Kjer asyncio brije

```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)
```

## Zakaj je to pomembno

asyncio je sodoben pristop k **visoki sočasnosti I/O** v Pythonu, ki poganja ogrodja kot je FastAPI in omogoča učinkovito ravnanje s tisoči sočasnih povezav na enem niti — veliko lažje kot nit-na-povezavo.

Razumevanje korutin, `await`, sočasnega izvajanja z `gather` in posebej **temeljnega pravila** (nikoli ne blokiraj zanke dogodkov; preloži CPU/blokirajoče delo) je bistveno za pisanje zmogljivega asinhronega Pythona.

Znanje o tem, kdaj se je to primerno (I/O-bound concurrency) v primerjavi s tem, kdaj ni (CPU-bound → multiprocessing), je ključno za njegove učinkovitost.