Cooperative cancellation

Opening your lesson

Canceling a task requests that it stop at a cooperative boundary. The caller still owns the task until its cleanup has finished. Returning immediately after cancel can leave a resource or an unfinished effect behind.

You run an actual cancellation example, then implement deterministic stop, retry and deadline policies. These are separate contracts: canceling owned work, deciding whether to admit work and deciding whether a supplied failure is retryable. A retry limit includes the first attempt. An absolute deadline includes the expected work needed to finish. Keep expected failures narrow rather than catching every exception and hiding a programming error. The cancellation example awaits all owned tasks so the returned event trace includes every finally block.

import json

async def process_payload(payload: str) -> str:
    data = json.loads(payload)
    import asyncio
    events = []
    async def work(item):
        events.append('start:' + item)
        try:
            while True:
                await asyncio.sleep(0)
        finally:
            events.append('close:' + item)
    tasks = [asyncio.create_task(work(item)) for item in data]
    await asyncio.sleep(0)
    for task in tasks:
        task.cancel()
    await asyncio.gather(*tasks, return_exceptions=True)
    return json.dumps(events,separators=(',',':'))

Cancel and await owned tasks so every finally block finishes exactly once. A cancel request must be followed by awaiting the task, so its finally block can run. The event trace records one start and one cleanup per task; no orphaned task remains when the function returns.

Choose your character

Your Work Gym account