Краткий ответ

При завершении asyncio.run незавершённая фоновая задача будет отменена и обычно не успеет завершить работу. Она получит CancelledError при ближайшей точке приостановки, а затем event loop будет закрыт.

Если задачу необходимо гарантированно завершить, её нужно явно ожидать или включить в управляемую группу задач. Для работы, которая должна пережить завершение процесса, нужен внешний брокер или отдельный рабочий сервис, а не фоновая задача asyncio.

Исторический контекст

Высокоуровневый запуск через asyncio.run предназначен для управления полным жизненным циклом event loop: создания, выполнения основной корутины и корректного завершения асинхронных ресурсов. Такой подход избавляет приложение от ручного управления циклом событий и уменьшает риск оставить незавершённые задачи.

Фоновое выполнение через create_task решает другую задачу: оно позволяет запланировать корутину и продолжить выполнение текущей корутины. Однако создание задачи не означает, что она получит отдельный жизненный цикл или переживёт закрытие event loop.

Постановка проблемы

Типичная ошибка — запустить отправку аудита, уведомления или сохранение данных через create_task, а затем сразу вернуть результат обработчика. Если после этого завершается asyncio.run, event loop начинает остановку и отменяет все оставшиеся задачи.

Неверное решение может привести к недоставленному сообщению, незаписанному событию или частично выполненной операции. Дополнительный риск возникает, если задача подавляет CancelledError и продолжает бесконечную работу: корректное завершение event loop тогда может задержаться.

Подробное решение

При закрытии asyncio.run находит незавершённые задачи event loop и вызывает для них Task.cancel(). Отмена не убивает выполнение мгновенно: корутина узнаёт о ней, когда управление доходит до очередного await или другой точки, в которой задача может обработать исключение CancelledError.

Если корутина корректно не подавляет это исключение, задача завершается со статусом отменённой. Код очистки следует размещать в finally; если отмену нужно пробросить дальше, после очистки следует не скрывать CancelledError.

import asyncio

async def background():
    try:
        await asyncio.sleep(10)
        print("готово")
    except asyncio.CancelledError:
        print("задача отменена")
        raise

async def main():
    asyncio.create_task(background())
    await asyncio.sleep(0.01)

asyncio.run(main())

В этом примере main завершается раньше background, поэтому при остановке asyncio.run фоновая задача будет отменена. Само наличие ссылки на объект задачи не меняет факт закрытия event loop, хотя сильная ссылка важна для контроля задачи до завершения приложения.

Для связанных задач предпочтителен asyncio.TaskGroup: он связывает их жизненный цикл и позволяет дождаться завершения либо централизованно обработать ошибку. Для одной обязательной операции достаточно сохранить задачу и выполнить await перед завершением соответствующего жизненного цикла.

Ситуация из практики

HTTP-обработчик записывает заказ в базу данных и параллельно создаёт фоновую задачу отправки уведомления. После отправки ответа обработчик завершается, а серверный тестовый запуск закрывает event loop. Уведомление иногда не отправляется — не из-за ошибки SMTP, а из-за отмены задачи при завершении loop.

Вариант с безусловным await надёжен, но увеличивает задержку ответа и делает доступность уведомлений частью критического пути. Вариант с create_task без ожидания быстрее, но не гарантирует выполнение. Вариант с отдельным брокером сообщений требует дополнительной инфраструктуры, зато позволяет повторять доставку и не связывает её с жизненным циклом HTTP-запроса.

Для критичного уведомления выбирают запись события в надёжную очередь или outbox в рамках транзакции базы данных. Для некритичного локального действия используют управляемую группу задач и явно ждут её завершения; это даёт предсказуемое поведение без иллюзии о гарантии после остановки процесса.

Что кандидаты часто упускают

Достаточно ли сохранить объект Task в переменной, чтобы он гарантированно завершился?

Нет. Ссылка позволяет наблюдать за задачей и предотвращает её преждевременное удаление сборщиком мусора в обычном сценарии, но не отменяет закрытие event loop. При остановке через asyncio.run незавершённая задача всё равно будет отменена.

Прекращается ли задача немедленно после вызова cancel?

Нет. cancel() только запрашивает отмену, устанавливая для задачи состояние, при котором CancelledError будет доставлен в корутину. Если корутина долго выполняет синхронный код без await, она не обработает отмену до возвращения управления event loop.

Что произойдёт, если корутина подавит CancelledError?

Она может продолжить работу или вернуть обычный результат, но это нарушает ожидаемую семантику отмены. При завершении event loop такая задача способна задержать остановку, если продолжает выполнять бесконечную или длительную работу. Подавлять отмену допустимо только при осознанной необходимости и с последующим завершением либо повторным распространением отмены.