swift-concurrency

Data races occur when multiple threads access shared memory unsafely. Swift 6 detects these via strict concurrency checking. Resolve them by isolating mutable state to actors, marking types as Sendable, and using async/await to coordinate access across isolation domains.

@MainActor isolates code to the main thread for UI updates and is required for UIKit/SwiftUI view properties. Actor isolation confines mutable state to a custom actor for background work. Choose @MainActor for UI-coupled logic and actors for concurrent, non-UI tasks.

Replace blocking calls with async alternatives, mark the function async, and await results. Apply actor isolation by making the function a member of an actor or @MainActor type. Add nonisolated for read-only helpers. Test with concurrent calls to verify no data races occur.

Sendable marks types as safe to pass across isolation boundaries and between threads. Value types and immutable reference types conform automatically. For mutable classes, adopt Sendable explicitly only if internal state is protected by locks or actor isolation.

Yes. Replace delegate callbacks with async functions that suspend and resume when work completes. Use continuations or structured concurrency to bridge old callback-based APIs. Maintain actor isolation throughout to prevent data races during migration.

Long-running CPU work on the main thread blocks UI updates even in async code. Offload heavy computation to a background actor using Task or DispatchQueue.global(), then return results to @MainActor for UI updates. Use proper isolation to keep threads responsive.