8.15. Подводные камни

Те же паттерны, которые делают asyncio приятным – отсутствие вытеснения, явные awaits – порождают собственный набор ситуаций, которые могут навредить. Эта страница – каталог тех из них, что встречаются достаточно часто, чтобы о них стоило знать.

8.15.1. Забытый await

Вызов функции async def возвращает объект корутины. Он не выполняет тело функции. Чтобы действительно его выполнить, корутину нужно awaitить или обернуть в задачу:

async def main():
    send_request()              # bug: returns the coroutine, does nothing
    await send_request()        # right: run it to completion
    asyncio.create_task(send_request())  # right: run it concurrently

Ошибка молчаливая – объект корутины создаётся, отбрасывается и никогда не выполняется. Приложение продолжает работу так, будто всё сработало. MicroPython иногда выводит предупреждение о том, что корутина так и не была ожидаема; иногда нет. Проверяйте на пропущенные awaits каждое место вызова, которое выглядит как вызов функции.

8.15.2. Плотные циклы без await

Корутина, которая работает в цикле и никогда не awaits, монополизирует цикл событий. Ни одна другая задача не продвигается, пока цикл не завершится или не уступит управление:

async def counter():
    n = 0
    while True:
        n += 1               # bug: starves the loop

Решение – уступка управления внутри цикла – обычно await asyncio.sleep_ms(0) – чтобы другие готовые задачи получили шанс выполниться. Вычислительно тяжёлая работа тоже относится к этой форме: цикл обработки изображений, выполняющийся сотни миллисекунд за итерацию, должен уступать управление хотя бы раз за итерацию, чтобы остальная часть программы не зависала.

8.15.3. Проглатывание CancelledError

На странице об отмене это уже подробно рассматривалось. Повторяем здесь, потому что это самая частая причина проблемы «моё приложение не завершается»: корутина перехватывает asyncio.CancelledError для целей очистки и забывает повторно его возбудить. Задача продолжает работать; вызывающая сторона, запросившая отмену, бесконечно ждёт её завершения. Всегда повторно возбуждайте исключение после очистки или используйте блок try/finally вместо явного except.

8.15.4. Изменение общего состояния между await

Кооперативное планирование гарантирует, что корутина владеет процессором единолично между await, но как только она awaits, может выполниться другая корутина. Если две корутины изменяют одну и ту же структуру данных шагами, включающими await, их операции могут чередоваться так, что это повредит структуру:

# bug: two tasks running do_work simultaneously can
# interleave around the await and corrupt items
async def do_work():
    n = len(items)
    await asyncio.sleep_ms(0)
    items.append(some_work(n))

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

8.15.5. await на уровне модуля

await допустим только внутри тела async def. Запись его на уровне модуля – вне какой-либо корутины – является синтаксической ошибкой:

# bug: not inside an async def
result = await fetch()

Решение – поместить работу в корутину и вызвать её из точки входа программы asyncio.run().

8.15.6. Несколько вызовов asyncio.run

В MicroPython один цикл событий. Вызов asyncio.run() дважды подряд – один раз для настройки, один раз для основной работы – всё равно использует тот же цикл. Вызов его изнутри работающей корутины является ошибкой: цикл уже запущен. Оба случая чаще всего возникают, когда скрипт растёт органически, и автор пытается расширить его, добавляя новые вызовы run() вместо того, чтобы влить новую работу в существующий main.

8.15.7. Использование Event из прерывания

asyncio.Event.set() безопасно вызывать только изнутри цикла событий. Вызов его из обработчика прерывания GPIO создаёт опасность повреждения. Для пробуждения задачи из прерывания используйте вместо этого ThreadSafeFlag – страница о нём описывает эту форму.

8.15.8. Длительные синхронные вызовы

Корутина может ожидать собственные примитивы ожидания asyncio; всё остальное, что она вызывает, выполняется синхронно и блокирует цикл до своего возврата. Блокирующий time.sleep() на 200 мс, запись на SD-карту, на сброс которой уходит 80 мс, сжатие большого JPEG, вызов csi.CSI.snapshot() – каждый из них удерживает цикл событий на всё своё время. Решение зависит от вызова:

  • Для time.sleep: замените его на await asyncio.sleep или await asyncio.sleep_ms.

  • Для csi.CSI.snapshot: используйте асинхронную обёртку snapshot, которую строит страница о захвате.

  • Для длительных вычислений (обработка изображений, кодирование JPEG): примите эту цену или разбейте работу на части, которые await между итерациями.

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