TaskGroup vs asyncio.gather: Choosing the Right Cancellation Strategy for Deterministic Resource Cleanup

Answer to the Core Question

For deterministic, ordered cleanup of external resources, manual cancellation via asyncio.gather is the safer choice. It lets you cancel tasks in a defined sequence, guaranteeing that cleanup code runs in the order you specify, independent of the event‑loop’s scheduling quirks.

Why TaskGroup Is Less Deterministic

• When a TaskGroup is cancelled, the group sends cancel() to all children simultaneously.
• Each child task only reacts when it reaches the next await point; the exact moment that happens is governed by the loop’s scheduler and can vary between runs.
• Because the cancellation signals are issued concurrently, the order in which the cleanup code (typically in finally blocks) executes is nondeterministic.

How Manual Gather Gives You Control

• After creating the tasks, you can call Task.cancel() on them one by one, in any order you like.
• The cancellation propagates immediately to the targeted task; its cleanup code runs as soon as it yields control back to the loop.
• Because you decide the sequence, you can enforce a strict order (e.g., close file handles before releasing database locks).

Influencing Order Inside a TaskGroup

• Python 3.11 does not expose task priorities or a way to reorder cancellation within a TaskGroup.
• The only ordering guarantee is that the group cancels children in the order they were added, but the actual execution order remains unpredictable.
• Attempting to “prime” tasks with await asyncio.sleep(0) or similar tricks does not change the fundamental nondeterminism.

Exception Aggregation Differences

Mechanism	Exception Handling
TaskGroup	Raises a single TaskGroupException that wraps all child exceptions. The wrapped exceptions are accessible via exc.exceptions.
asyncio.gather (default)	Propagates only the first exception encountered; subsequent exceptions are ignored unless return_exceptions=True is set.
asyncio.gather (return_exceptions=True)	Returns a list containing either results or exception objects for each task, preserving the original order of the input coroutines.

Practical Steps for Deterministic Cleanup

1. Wrap each external‑resource‑using coroutine in a try/finally block that releases the resource in finally.
2. Create the tasks with asyncio.create_task() and store them in a list.
3. When cancellation is needed, iterate over the list in the desired order and call task.cancel() on each.
4. Await each task inside a try/except that catches asyncio.CancelledError so the cleanup code can run.
5. If you prefer TaskGroup, accept the nondeterministic order or implement an explicit cancellation queue outside the group.

Diagnostic Detail That Could Change the Recommendation

If your cleanup logic must run *exactly* when a task is cancelled (e.g., it uses async with context managers that react to cancellation), confirm whether those context managers guarantee execution on CancelledError. If not, you might need to wrap the coroutine in a try/finally that explicitly handles cancellation.