Jet School Logo

Что такое Корутины?

Корутины (coroutines) — это специальные функции, выполнение которых можно приостановить, а затем продолжить с того же места. В Python они лежат в основе асинхронного программирования. Пока корутина ждёт завершения операции — например, ответа из интернета, — она «отходит в сторону», и программа в это время может заниматься другими задачами.

Проще говоря: корутины похожи на умелого повара. Он не стоит без дела, пока закипает вода, — он нарезает овощи, готовит соус, а потом возвращается к воде. Он не делает два дела одновременно, но не тратит время ожидания впустую.

Обычная функция и корутина

  • Обычная функция начинает работу при вызове и полностью завершает её, возвращая результат через return. Остановиться посередине она не может.
  • Корутина может временно приостановиться на выражении await, передать управление другим задачам и, когда ожидаемая операция завершится, продолжить с того же места. Все её локальные переменные при этом сохраняются.

Как создать и запустить корутину?

В Python корутина создаётся с помощью ключевых слов async def, а внутри неё для ожидания других асинхронных операций используется await.

Простой пример: допустим, мы пишем корутину privetstvie. Сначала она выводит на экран «Привет», затем командой await asyncio.sleep(2) ждёт 2 секунды и наконец выводит «Через 2 секунды снова привет!». Чтобы запустить корутину, используется команда asyncio.run(privetstvie()).

⚠️ Самая частая ошибка: если вызвать корутину как обычную функцию — просто написав privetstvie(), — код не выполнится. Python лишь создаст «объект корутины» и выдаст предупреждение, что его так и не дождались, — «was never awaited». Корутину обязательно нужно запускать через await или asyncio.run().

Цикл событий (event loop)

«Диспетчер», управляющий корутинами, называется циклом событий (event loop). Он следит за всеми корутинами: как только одна начинает ждать, он сразу запускает другую, а когда ожидаемая операция завершается, возобновляет первую с того же места. В Python цикл событий обеспечивает стандартный модуль asyncio.

Несколько корутин вместе

Пример: у нас есть две корутины — pervaya и vtoraya. Каждая сначала выводит «началась», затем ждёт 1 секунду и наконец выводит «завершена». Если запустить их вместе с помощью функции asyncio.gather(), на экране сначала появятся «Первая началась» и «Вторая началась», а через 1 секунду — «Первая завершена» и «Вторая завершена».

Программа занимает не 2, а всего 1 секунду. Причина: как только первая корутина начинает ждать, цикл событий запускает вторую, и они ждут одновременно.

Важное различие: конкурентность и параллелизм

В этом примере корутины не работают параллельно. В asyncio все корутины работают в одном потоке (thread), на одном ядре процессора, и выполняются по очереди. Это называется конкурентностью (concurrency): несколько задач продвигаются в одном и том же промежутке времени, но в каждый конкретный момент реально выполняется только одна.

А параллелизм (parallelism) — это выполнение задач действительно одновременно, на разных ядрах процессора. В Python для этого используют не корутины, а многопроцессное программирование (multiprocessing).

Возвращаясь к сравнению с поваром: корутины — это один повар, который умно использует время ожидания. А параллелизм — это несколько поваров, работающих одновременно.

Когда корутины полезны?

Полезны — в задачах с большим количеством ожидания (I/O-bound):

  • загрузка множества страниц из интернета;
  • одновременная отправка запросов к нескольким API;
  • веб-серверы и чаты, одновременно обслуживающие тысячи пользователей;
  • запросы к базам данных.

Бесполезны — в тяжёлых вычислениях (CPU-bound): при вычислениях с большими числами или обработке изображений «ожидания» нет, процессор постоянно занят. Такие задачи корутины не ускоряют.

Внимание: если внутри корутины использовать обычный time.sleep() или другую блокирующую команду, остановится вся программа, ведь цикл событий тоже будет заблокирован. Внутри корутин всегда нужно использовать асинхронные аналоги — например, asyncio.sleep(). Чтение и запись обычных файлов тоже не становятся асинхронными автоматически — для этого нужны специальные библиотеки.

Преимущества

  • Идеальны для неблокирующих операций.
  • Позволяют эффективно и конкурентно выполнять множество задач, требующих ожидания.
  • Экономят ресурсы: тысячи корутин требуют гораздо меньше памяти, чем тысячи потоков.

Краткая история и другие языки

В Python идея корутин сначала реализовывалась на основе генераторов — с ключевым словом yield. А современный синтаксис async/await появился в 2015 году в версии Python 3.5.

Корутины и похожие понятия есть и в других языках:

  • async/await в JavaScript — очень похож на Python;
  • coroutines в Kotlin;
  • goroutines в языке Go.

Заключение

Корутины — мощный инструмент, позволяющий эффективно управлять множеством задач, требующих ожидания. Чтобы правильно их использовать, важно понимать ключевые слова async и await, цикл событий и разницу между конкурентностью и параллелизмом.

Хотите применить эти знания на практике и получить реальные результаты? Начните обучение на курсе «IT и Компьютерная инженерия» и шаг за шагом приобретайте практические навыки. Подробнее о курсе — перейдите по ссылке: Курс «IT и Компьютерная инженерия».

Заполните форму чтобы узнать больше о наших IT курсах

Начни изучать IT уже сегодня