swift-concurrency

Apply structured concurrency patterns by preferring async/await and TaskGroup over unstructured Task usage to ensure correct cancellation and error propagation, while enforcing Actor isolation to safely protect shared mutable state across asynchronous boundaries.

The best way to handle shared mutable state in Swift concurrency is using Actors and @MainActor. Actors serialize access to their state, while @MainActor confines UI-related work to the main thread, keeping interfaces responsive without explicit locking mechanisms.

Use Sendable and @Sendable to mark types and closures that cross concurrency boundaries as safe. This ensures value types are immutable or safely synchronized, satisfying Swift 6 strict concurrency checks and preventing data races during concurrent execution.

Manage cancellation in Swift networking and streaming tasks by using structured concurrency patterns like TaskGroup. This ensures that when a parent task is cancelled, the cancellation automatically propagates to all child tasks, preventing orphaned network requests and resource leaks.

Yes, Swift structured concurrency works seamlessly with AsyncSequence for streaming data. You can iterate over an AsyncSequence using async/await within a TaskGroup, ensuring proper cancellation propagation and structured error handling across your streaming workflows.

Swift actor reentrancy can cause unexpected state mutations when an actor method suspends and allows another interleaving task to execute. Prevent this hazard by minimizing suspension points within actor methods and validating state after awaiting external asynchronous calls.