swift-concurrency_skill

Overview

This skill explains Swift 6 strict concurrency: async/await, actors, @MainActor, Sendable, and techniques for thread-safe code. It focuses on migration from GCD to structured concurrency and practical patterns to avoid data races and reentrancy pitfalls. Use it to design safe concurrency for iOS and macOS targets with Swift 6.x and Xcode 26+.

How this skill works

The skill inspects core concurrency primitives and shows idiomatic usage: async functions, async sequences, Task and TaskGroup APIs, actors and nonisolated members, MainActor isolation, and the Sendable protocol. It highlights compiler-enforced data-race safety in Swift 6, demonstrates safe bridging of legacy callbacks with continuations, and covers common pitfalls and migration steps from DispatchQueue to structured concurrency.

When to use it

• When converting GCD/DispatchQueue code to async/await
• When designing actor-based state management for shared mutable data
• When you need to ensure UI updates run on the main thread via @MainActor
• When you must make types safe to cross concurrency boundaries using Sendable
• When diagnosing data races, actor reentrancy, or non-Sendable captures

Best practices

• Prefer actors for mutable shared state and mark UI classes @MainActor
• Use Task, Task.detached, and TaskGroup for structured parallel work and cancellation
• Make value types Sendable; mark complex synchronized classes @unchecked Sendable only with care
• Avoid DispatchQueue.main.async for UI updates—use await MainActor.run or @MainActor contexts
• Capture weak references for non-Sendable objects inside Task and jump back to MainActor for UI

Example use cases

• Fetch multiple network resources concurrently with withThrowingTaskGroup and preserve ordering
• Implement an ImageCache actor that deduplicates in-flight downloads and caches results
• Migrate a completion-handler API to async/await using withCheckedThrowingContinuation
• Wrap publisher sinks to update @Published properties safely on MainActor
• Run background processing in Task and update UI with await MainActor.run