Как работает async/await с asyncio?

Question

IT Interview Practice · Accepted Answer

**asyncio** — это framework Python для **конкурентного I/O** с использованием `async`/`await`. Он выполняет множество операций I/O кооперативно на **одном потоке** через event loop — эффективно для I/O-bound работы с высокой конкурентностью (сетевые вызовы, веб-серверы) без overhead потоков.

## Определение и запуск корутин

```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` — это **корутина**; `await` приостанавливает её в точке I/O, позволяя event loop запустить *другие* корутины тем временем — затем возобновляется, когда ожидаемая операция завершится.

## Ключевое преимущество: конкурентный 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` запускает корутины **конкурентно** — пока одна ожидает I/O, остальные продолжают работу. Три ожидания по 1 секунде перекрываются в ~1 секунду всего. Это ключевое достоинство: перекрытие множества I/O ожиданий на одном потоке.

## Отличие от потоков

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

## Почему это важно

asyncio — это современный подход к **высокой конкурентности I/O** в Python, питающий фреймворки вроде FastAPI и позволяющий эффективно обрабатывать тысячи одновременных соединений на одном потоке — намного легче, чем поток-на-соединение.

Понимание корутин, `await`, конкурентного выполнения с `gather`, и особенно **кардинального правила** (никогда не блокируй event loop; делегируй CPU/блокирующую работу) необходимо для написания производительного асинхронного Python.

Знание того, когда это подходит (I/O-bound concurrency) в сравнении с когда нет (CPU-bound → multiprocessing) — ключ к эффективному его использованию.

## Главное правило: не блокируй 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)
```

Поскольку это кооперативно и однопоточно, любой блокирующий/CPU-тяжёлый вызов замораживает *все* корутины. Используй await-ные async API, и делегируй блокирующую/CPU работу executor-у.

## Где asyncio сияет

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

Определение и запуск корутин

Ключевое преимущество: конкурентный I/O

Отличие от потоков

Почему это важно

Главное правило: не блокируй event loop

Где asyncio сияет

Похожие вопросы