Семантика отмены: внедрённый CancelledError, баг бессмертия через голый except и уборка, обязанная пере-бросить

Отмена — это внедрённое исключение, а не флаг

task.cancel() ничего не останавливает. Он договаривается с циклом, что тот бросит CancelledError в корутину в её следующей точке приостановки — механически Task возобновляет корутину через coro.throw(CancelledError()) вместо send() (машинерия урока 1, поставленная на боевой взвод). Две вещи определяют всю модель. Первая: код между await непрерываем — это гарантия (обновление словаря или двухшаговая смена состояния никогда не будут разорваны отменой пополам) и одновременно ловушка (30-секундный отрезок чистого CPU неотменяем всю свою длительность, потому что throw негде приземлиться). Вторая: отмена доставляется только на await, которые реально приостанавливают, — различение из урока 1 возвращается с зубами. await завершённой футуры или синхронно цепляющейся корутины — не точка отмены. Для длинных CPU-секций, обязанных оставаться отзывчивыми к отмене, честный приём — периодический await asyncio.sleep(0): он вставляет настоящую приостановку, куда throw может приземлиться, ценой круга через цикл на каждую проверку.

Баг проглатывания, точно

Сколько кодовых баз прячет бессмертную задачу в shutdown? Больше, чем кажется — и механизм умещается в одно неверное слово в блоке исключения. С Python 3.8 CancelledError наследуется от BaseException (базовый класс всех исключений Python, включая системные) — намеренное ломающее изменение, сделанное ради того, чтобы самый частый защитный паттерн стал безопасным:

async def worker(q):
    while True:
        job = await q.get()
        try:
            await handle(job)
        except Exception:        # НЕ ловит CancelledError (3.8+): хорошо
            log.exception("джоб упал, продолжаем")
        # except:                # ловит BaseException: отмена умирает здесь
        # except BaseException:  # тот же баг, написанный честно

except Exception пропускает отмену насквозь — задача разматывается и заканчивается в состоянии cancelled, ровно как хотел отменяющий. Голый except (или except BaseException) её ловит, и если обработчик после этого продолжает цикл, задача бессмертна: cancel() вернул True, исключение доставлено — и ничего не умерло. Это и был баг из Хука, а по духу он старше 3.8 — до 3.8 даже except Exception глотал отмену, поэтому старые кодовые базы — минные поля. Дисциплина на случай, когда отмену нужно увидеть: поймать, убраться, пере-бросить:

        except asyncio.CancelledError:
            await q.nack(job)    # вернуть джоб в полёте (ограничьте это! см. ниже)
            raise                # ВСЕГДА — отменяющему причитается размотка

У проглатывания без re-raise есть вторая цена, кроме бессмертия: await task после этого возвращается нормально, task.cancelled() — False, и вся машинерия фреймворков, проверяющая «сработал ли мой cancel» — TaskGroup, таймаут-скоупы, — получает ложь.

await в finally: ловушка двойной отмены

Уборка, которая сама делает await, — место, где зависает корректно выглядящий код. Отменённая задача выполняет свои finally-блоки по мере размотки исключения — но await внутри finally — это новая точка приостановки, и второй cancel() (нетерпеливый цикл shutdown, истекающий вокруг вас таймаут-скоуп) приземляется ровно туда, бросив остаток уборки. Хуже: сам await уборки может заблокироваться навсегда — nack() мёртвому брокеру — и теперь задача неубиваема-из-вежливости. Дисциплина: ограничивайте каждый await на пути отмены. Оборачивайте уборку в asyncio.timeout(...) (следующий урок разберёт его), или шилдите по-настоящему обязанную завершиться работу; никогда не позволяйте уборке ждать тех же условий, что вызвали отмену.

finally:
    with contextlib.suppress(TimeoutError):
        async with asyncio.timeout(2):   # уборке даётся 2 с, не вечность
            await q.nack(job)

TaskGroup: структурная отмена и чей это был cancel

Поведение TaskGroup вы знаете из юнита про конкурентность: первый сбой ребёнка отменяет соседей, результаты приходят как ExceptionGroup (тип исключения Python 3.11+, объединяющий несколько исключений в одно). Глубокая деталь — как он отличает внутреннюю отмену (группа отменяет собственных детей) от внешней (кто-то отменил всю группу снаружи): каждая задача держит счётчик отмен — cancel() инкрементирует, uncancel() декрементирует. Когда TaskGroup или таймаут-скоуп отменяет тело по своим причинам, позже он вызывает uncancel(), чтобы погасить свой запрос и решить: счётчик вернулся к нулю — отмена была моя, докладываем сбой соседа (или TimeoutError); всё ещё положительный — в полёте есть и внешняя отмена, и она обязана распространяться дальше. Честно: uncancel() — машинерия фреймворков, прикладной код её почти не вызывает, — но знание о ней объясняет, почему проглатывание CancelledError внутри TaskGroup или таймаут-скоупа портит их бухгалтерию и почему правило re-raise — не этикет, а протокол.