Главная › Блог › Python › Asyncio в Python: event loop, корутины и вопросы на собеседовании

Asyncio в Python: event loop, корутины и вопросы на собеседовании

Зачем asyncio, если есть потоки

Asyncio решает задачу конкурентного ожидания I/O без накладных расходов на потоки операционной системы. Поток — это тяжёлая сущность: стек, контекст, переключение через ядро ОС. Корутина — это объект в памяти интерпретатора, переключение между корутинами происходит кооперативно в потоке event loop, когда задача приостанавливается. Для backend-сервиса, который держит много соединений и значительную часть времени ждёт ответа от БД или внешнего API, такой подход снижает накладные расходы на планирование по сравнению с моделью «поток на соединение».

Представь официанта в ресторане. Поток на каждый заказ — это отдельный повар, который стоит у плиты и ждёт, пока сварится бульон, ничего не делая. Asyncio — это один повар, который ставит бульон вариться, идёт резать овощи для другого заказа, а когда таймер звякнет — возвращается. Один исполнитель, несколько задач в работе одновременно за счёт переключений в моменты ожидания.

Event loop: что это и как он работает

Event loop — ядро любого приложения на asyncio: он запускает асинхронные задачи и callback'и, выполняет сетевые операции ввода-вывода и управляет подпроцессами. Корутина — это функция, объявленная через async def, которая при простом вызове не выполняется — вызов лишь создаёт объект-корутину. Чтобы она реально начала работать, её нужно запланировать: через await, asyncio.create_task или верхнеуровневую функцию asyncio.run.

Ключевое слово await — это точка, где корутина может отдать управление обратно в event loop (например, ожидая результата другой корутины, Task или Future). Если внутри нет ни одного await на операции, которая реально приостанавливает выполнение, корутина с практической точки зрения выполняется как обычная функция, обёрнутая в асинхронный интерфейс.

import asyncio
import time

async def fetch(name, delay):
    print(f"{name}: старт")
    await asyncio.sleep(delay)  # здесь отдаём управление
    print(f"{name}: финиш")
    return name

async def main():
    start = time.monotonic()
    results = await asyncio.gather(
        fetch("A", 2),
        fetch("B", 1),
    )
    print(results, time.monotonic() - start)  # ~2 секунды, не 3

asyncio.run(main())

asyncio.gather оборачивает переданные корутины в Task и запускает их конкурентно: пока одна ждёт в sleep, event loop может переключиться на другую. Итоговое время работы примера — около максимума из задержек, а не суммы, аналогично примеру с двумя create_task в официальной документации.

Task vs корутина vs Future

  • Корутина — описание того, что нужно сделать; сама по себе не выполняется, пока её не запланируют (через await, create_task или аналогичный механизм).
  • Task — объект, который выполняет корутину; asyncio.create_task оборачивает корутину в Task и планирует её выполнение в event loop.
  • Future — низкоуровневый примитив, представляющий результат асинхронной операции, который появится в будущем; Task — подкласс Future. Документация рекомендует не создавать Future напрямую в пользовательском коде, а использовать loop.create_future() там, где это необходимо.
Если вызвать корутину без await и без планирования через create_task, код тела корутины не выполнится вовсе — вы получите только объект корутины и предупреждение RuntimeWarning «coroutine was never awaited». Корутина — лёгкий объект, а не поток, который стартует сам по себе.

Блокирующий код — главный враг event loop

Если внутри корутины вызвать синхронную блокирующую функцию (например, requests.get или time.sleep вместо asyncio.sleep), поток, в котором выполняется event loop, заблокируется целиком — другие задачи не смогут продвинуться, пока блокирующий вызов не завершится. Это отличие от классической многопоточности с вытесняющим планированием ОС: здесь переключение кооперативное и происходит только в точках, где корутина явно отдаёт управление.

Для блокирующих операций документация предлагает loop.run_in_executor — метод, который выполняет вызов в пуле потоков (по умолчанию) или процессов, не блокируя сам event loop.

import asyncio

def cpu_bound_work(n):
    return sum(i * i for i in range(n))

async def main():
    loop = asyncio.get_running_loop()
    result = await loop.run_in_executor(None, cpu_bound_work, 10_000_000)
    print(result)

Вопросы с собеседований

Чем корутина отличается от потока и от генератора?
От потока — корутина не требует системного переключения контекста, выполняется в рамках event loop, переключение происходит кооперативно через await. От генератора — по спецификации PEP 492, нативная корутина (async def) возвращает объект-корутину так же, как генератор возвращает объект-генератор, но семантически устроена иначе: StopIteration внутри корутины не распространяется наружу, а заменяется на RuntimeError; если корутина была собрана сборщиком мусора, не будучи ни разу awaited, выдаётся RuntimeWarning.
Что будет, если забыть await перед вызовом async-функции?
Тело функции не выполнится — вызов вернёт объект корутины, а при последующей сборке мусора такого объекта будет выдано RuntimeWarning «coroutine was never awaited». Побочные эффекты внутри корутины не произойдут, потому что её код не запускался.
Как в asyncio работает конкурентность при одном потоке?
Event loop поддерживает очередь готовых к выполнению задач и наблюдает за вводом-выводом через системные механизмы ОС. Когда корутина доходит до await на операции, которая ещё не завершена, управление возвращается циклу, который может переключиться на другую готовую задачу. Параллелизма на уровне нескольких ядер CPU это не даёт — есть конкурентность за счёт переключений в моменты ожидания.
Почему time.sleep в корутине — это плохо?
time.sleep блокирует весь поток, в котором работает event loop, — остальные задачи не могут продвинуться на это время. Нужно использовать asyncio.sleep, которое является awaitable и не блокирует поток целиком.
В чём разница между asyncio.gather и asyncio.wait?
gather автоматически планирует переданные корутины как Task и возвращает список результатов. wait — более низкоуровневая функция: в Python 3.11+ она принимает набор Task/Future (передавать объекты корутин напрямую нельзя) и параметр return_when (FIRST_COMPLETED, FIRST_EXCEPTION или ALL_COMPLETED, по умолчанию ALL_COMPLETED), а возвращает два множества — done и pending, а не сами значения результатов.
Как совместить синхронный блокирующий код с asyncio?
Через loop.run_in_executor, который выполняет функцию в пуле (по умолчанию — ThreadPoolExecutor, либо явно переданном ProcessPoolExecutor), не блокируя сам event loop. Выбор между потоками и процессами зависит от характера задачи: для операций, которые преимущественно ждут I/O, достаточно пула потоков; для тяжёлых вычислений стоит рассмотреть пул процессов.

Ещё разборы