Swift concurrency

Swift Concurrency

Priority: P0

Implementation Guidelines

async/await (Structured Concurrency)

• Async Functions: Mark with async and call with await.
• async let: Use async let for parallel execution when multiple tasks are independent.
• Task Groups: Use withTaskGroup or withThrowingTaskGroup for spawning a dynamic number of tasks.
• Error Handling: Combine with throws. Always handle CancellationError.

Actors (Thread Safety)

• Data Isolation: Use actor for shared mutable state to avoid data races.
• @MainActor: Annotate UI classes (Views, ViewModels) with @MainActor for main thread execution. Use MainActor.run { ... } for inline UI updates in async blocks.
• Global Actors: Use @GlobalActor for specific thread-bound resources.
• nonisolated: Use nonisolated for methods that don't access actor state to avoid unnecessary hops.

Task Management

• Task Hierarchy: Inherit isolation by using Task { ... }.
• Cancellation: Explicitly check Task.isCancelled in long loops. Use try Task.checkCancellation() for throwing functions.
• Detached Tasks: Avoid Task.detached unless you explicitly want to break context inheritance.

Anti-Patterns

• No synchronous work in @MainActor: Do not block the main thread.
• No UI updates off @MainActor: Always dispatch back to main via MainActor.
• No ignored cancellation: Always check and propagate cancellation.

References

• async/await & Actors