Kaip veikia async/await su asyncio?

Question

IT Interview Practice · Accepted Answer

**asyncio** yra Python framework'as **lygiagretiems I/O operacijoms** atlikti naudojant `async`/`await`. Jis valdo daug I/O operacijų kooperatyviai viename **gijoje** per įvykių ciklą (event loop) — efektyvus dideliam lygiagrečių I/O operacijų skaičiui (tinklo užklausoms, žiniatinklio serveriams) be gijų naštos.

## Korutinų apibrėžimas ir paleidimas

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

`async def` funkcija yra **korutina**; `await` ją sustabdo I/O taške, leidžiant įvykių ciklui paleisti *kitas* korutinas tuo tarpu — tada ją pratęsia, kai baigsis numatytas operacijas.

## Pagrindinis pranašumas: lygiagrečios I/O operacijos

```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` paleido korutinas **lygiagretiai** — kai viena laukia I/O, kitos tęsiasi. Trys 1 sekundės lūkesčiai sutrumpėja iki ~1 sekundės iš viso. Tai yra pagrindinė vertė: daug I/O lūkesčių sutapimas viename gijoje.

## Kaip tai skiriasi nuo gijų

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

## Pagrindinė taisyklė: neblokuokite įvykių ciklo

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

Nes tai kooperatyvu ir viengijis, bet koks blokuojantis/CPU-intensyvus kvietimas užšaldys *visas* korutinas. Naudokite `await`-inamus asinchroninius API ir perkelkite blokuojantį/CPU darbą į vykdytoją (executor).

## Kur asyncio iš tikrųjų pranašus

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

## Kodėl tai svarbu

asyncio yra šiuolaikinis **didelės I/O lygiagrečumo** požiūris Python'e, jis galina framework'us kaip FastAPI ir leidžia efektyviai tvarkyti tūkstančius lygiagrečių ryšių viename gijoje — daug lengviau nei gija-per-ryšį.

Supratimas apie korutinas, `await`, lygiagrečią vykdymą su `gather` ir ypač **pagrindinę taisyklę** (niekada neblokuokite įvykių ciklo; perkelkite CPU/blokuojantį darbą) yra būtinas veiksmingam asinchroniniam Python kodui rašyti.

Žinojimas, kada tai tinka (I/O-ribota lygiagrečumas) ir kada ne (CPU-ribota → daugprocesynas) yra raktas naudoti tai efektyviai.

Korutinų apibrėžimas ir paleidimas

Pagrindinis pranašumas: lygiagrečios I/O operacijos

Kaip tai skiriasi nuo gijų

Pagrindinė taisyklė: neblokuokite įvykių ciklo

Kur asyncio iš tikrųjų pranašus

Kodėl tai svarbu

Susiję klausimai