Swift Structured Concurrency: Task cancellation propagation across actor boundaries

Cancellation Behavior and Actor Isolation

In Swift 5.10+, cancellation propagation is guaranteed to be independent of actor mailbox queuing. When a parent task is cancelled, the cancellation state is propagated to all child tasks in the hierarchy immediately, regardless of which actor those children are isolated to.

State Change vs. Message Passing

The critical distinction in Swift's concurrency model is that cancellation is a state change on the Task object, not a message sent to an actor's mailbox. Because the cancellation signal does not travel through the actor's queue, it cannot be delayed by a congested mailbox.

Behavior Under High Load

While the cancellation state is updated instantly, the effect of that cancellation depends on the task's current status:

• Executing Tasks: If a child task is already running on an actor, it can detect the cancellation immediately by polling Task.isCancelled or calling try Task.checkCancellation().
• Queued Tasks: If a child task is waiting in an actor's mailbox, it remains in the queue. The system does not "jump the line" or automatically remove cancelled tasks from the mailbox. However, the moment that task begins execution, it will start with its cancellation state already set to true.

Implementation Steps for High-Load Environments

To ensure your system remains responsive under heavy actor load, implement the following cooperative patterns:

1. Immediate Entry Check: Call try Task.checkCancellation() as the very first line of any actor-isolated function. This ensures that tasks that spent significant time waiting in a congested mailbox terminate immediately without performing expensive work.
2. Frequent Polling: In long-running loops within an actor, check the cancellation state at the start of every iteration.
3. Avoid Blocking Calls: Ensure the actor is not blocked by synchronous, non-yielding code, as this prevents the actor from processing the next task in the queue (even if that task is already cancelled).

Verification Method

You can verify this behavior by creating a TaskGroup that spawns child tasks on a specific actor. Saturate that actor with several long-running synchronous operations to create a backlog. Cancel the parent task and observe that the child tasks, once they finally begin execution, immediately report Task.isCancelled == true.

Missing Diagnostic Detail: To provide a more tailored recommendation, are you using DistributedActor (across network boundaries) or standard local actor types? Cancellation propagation for Distributed Actors involves different transport-layer mechanisms.