swift-concurrency-expert

Swift concurrency data-race errors in Swift 6.2 are resolved by applying actor isolation, Sendable conformance, and @MainActor annotations to unsafe types. Review your codebase for shared mutable state, annotate UI-bound code with @MainActor, mark non-Sendable types as Sendable when safe, and isolate protocol conformances. This enforces compile-time safety without changing behavior.

@MainActor in Swift concurrency designates types and methods that must run on the main thread, typically UI components, view models, and app delegates. Use it for any code touching UIKit, SwiftUI state, or main-thread-only APIs. Swift 6.2 applies main-actor defaults to many framework types, so audit your codebase for conflicts.

Sendable conformance in Swift concurrency marks types as safe to share across actor boundaries by guaranteeing immutability or synchronized access. Swift 6.2 requires explicit Sendable conformance for types passed between actors; without it, the compiler raises data-race errors. Mark value types and immutable classes as Sendable, or use isolated properties and locks for mutable shared state.

Migrate UI code to Swift 6.2 concurrency by annotating view controllers, view models, and delegates with @MainActor, replacing DispatchQueue.main calls with isolated methods, and ensuring SwiftUI @Published properties are Sendable. Move long-running tasks to background actors marked @concurrent. Use the included references on SwiftUI concurrency patterns for step-by-step guidance.

Yes, actor isolation works with protocol implementations through isolated conformance in Swift 6.2. Mark protocol methods as isolated(actor) to enforce that implementations run on a specific actor, particularly for Sendable protocols. This prevents data-race violations when protocol types cross actor boundaries.

Common Swift concurrency issues beyond Sendable include unawaited async tasks, main-thread violations in background code, and unsafe access to shared mutable state. Swift 6.2 flags these as compiler errors. Apply @concurrent to offload work from the main actor, use Task groups for structured concurrency, and wrap mutable state in actors or serial dispatchers.