Swift Concurrency 6 2

1---2name: swift-concurrency-6-23description: Swift 6.2 Approachable Concurrency — single-threaded by default, @concurrent for explicit background offloading, isolated conformances for main actor types.4---5 6# Swift 6.2 Approachable Concurrency7 8Patterns for adopting Swift 6.2's concurrency model where code runs single-threaded by default and concurrency is introduced explicitly. Eliminates common data-race errors without sacrificing performance.9 10## When to Activate11 12- Migrating Swift 5.x or 6.0/6.1 projects to Swift 6.213- Resolving data-race safety compiler errors14- Designing MainActor-based app architecture15- Offloading CPU-intensive work to background threads16- Implementing protocol conformances on MainActor-isolated types17- Enabling Approachable Concurrency build settings in Xcode 2618 19## Core Problem: Implicit Background Offloading20 21In Swift 6.1 and earlier, async functions could be implicitly offloaded to background threads, causing data-race errors even in seemingly safe code:22 23```swift24// Swift 6.1: ERROR25@MainActor26final class StickerModel {27    let photoProcessor = PhotoProcessor()28 29    func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {30        guard let data = try await item.loadTransferable(type: Data.self) else { return nil }31 32        // Error: Sending 'self.photoProcessor' risks causing data races33        return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)34    }35}36```37 38Swift 6.2 fixes this: async functions stay on the calling actor by default.39 40```swift41// Swift 6.2: OK — async stays on MainActor, no data race42@MainActor43final class StickerModel {44    let photoProcessor = PhotoProcessor()45 46    func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {47        guard let data = try await item.loadTransferable(type: Data.self) else { return nil }48        return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)49    }50}51```52 53## Core Pattern — Isolated Conformances54 55MainActor types can now conform to non-isolated protocols safely:56 57```swift58protocol Exportable {59    func export()60}61 62// Swift 6.1: ERROR — crosses into main actor-isolated code63// Swift 6.2: OK with isolated conformance64extension StickerModel: @MainActor Exportable {65    func export() {66        photoProcessor.exportAsPNG()67    }68}69```70 71The compiler ensures the conformance is only used on the main actor:72 73```swift74// OK — ImageExporter is also @MainActor75@MainActor76struct ImageExporter {77    var items: [any Exportable]78 79    mutating func add(_ item: StickerModel) {80        items.append(item)  // Safe: same actor isolation81    }82}83 84// ERROR — nonisolated context can't use MainActor conformance85nonisolated struct ImageExporter {86    var items: [any Exportable]87 88    mutating func add(_ item: StickerModel) {89        items.append(item)  // Error: Main actor-isolated conformance cannot be used here90    }91}92```93 94## Core Pattern — Global and Static Variables95 96Protect global/static state with MainActor:97 98```swift99// Swift 6.1: ERROR — non-Sendable type may have shared mutable state100final class StickerLibrary {101    static let shared: StickerLibrary = .init()  // Error102}103 104// Fix: Annotate with @MainActor105@MainActor106final class StickerLibrary {107    static let shared: StickerLibrary = .init()  // OK108}109```110 111### MainActor Default Inference Mode112 113Swift 6.2 introduces a mode where MainActor is inferred by default — no manual annotations needed:114 115```swift116// With MainActor default inference enabled:117final class StickerLibrary {118    static let shared: StickerLibrary = .init()  // Implicitly @MainActor119}120 121final class StickerModel {122    let photoProcessor: PhotoProcessor123    var selection: [PhotosPickerItem]  // Implicitly @MainActor124}125 126extension StickerModel: Exportable {  // Implicitly @MainActor conformance127    func export() {128        photoProcessor.exportAsPNG()129    }130}131```132 133This mode is opt-in and recommended for apps, scripts, and other executable targets.134 135## Core Pattern — @concurrent for Background Work136 137When you need actual parallelism, explicitly offload with `@concurrent`:138 139> **Important:** This example requires Approachable Concurrency build settings — SE-0466 (MainActor default isolation) and SE-0461 (NonisolatedNonsendingByDefault). With these enabled, `extractSticker` stays on the caller's actor, making mutable state access safe. **Without these settings, this code has a data race** — the compiler will flag it.140 141```swift142nonisolated final class PhotoProcessor {143    private var cachedStickers: [String: Sticker] = [:]144 145    func extractSticker(data: Data, with id: String) async -> Sticker {146        if let sticker = cachedStickers[id] {147            return sticker148        }149 150        let sticker = await Self.extractSubject(from: data)151        cachedStickers[id] = sticker152        return sticker153    }154 155    // Offload expensive work to concurrent thread pool156    @concurrent157    static func extractSubject(from data: Data) async -> Sticker { /* ... */ }158}159 160// Callers must await161let processor = PhotoProcessor()162processedPhotos[item.id] = await processor.extractSticker(data: data, with: item.id)163```164 165To use `@concurrent`:1661. Mark the containing type as `nonisolated`1672. Add `@concurrent` to the function1683. Add `async` if not already asynchronous1694. Add `await` at call sites170 171## Key Design Decisions172 173| Decision | Rationale |174|----------|-----------|175| Single-threaded by default | Most natural code is data-race free; concurrency is opt-in |176| Async stays on calling actor | Eliminates implicit offloading that caused data-race errors |177| Isolated conformances | MainActor types can conform to protocols without unsafe workarounds |178| `@concurrent` explicit opt-in | Background execution is a deliberate performance choice, not accidental |179| MainActor default inference | Reduces boilerplate `@MainActor` annotations for app targets |180| Opt-in adoption | Non-breaking migration path — enable features incrementally |181 182## Migration Steps183 1841. **Enable in Xcode**: Swift Compiler > Concurrency section in Build Settings1852. **Enable in SPM**: Use `SwiftSettings` API in package manifest1863. **Use migration tooling**: Automatic code changes via swift.org/migration1874. **Start with MainActor defaults**: Enable inference mode for app targets1885. **Add `@concurrent` where needed**: Profile first, then offload hot paths1896. **Test thoroughly**: Data-race issues become compile-time errors190 191## Best Practices192 193- **Start on MainActor** — write single-threaded code first, optimize later194- **Use `@concurrent` only for CPU-intensive work** — image processing, compression, complex computation195- **Enable MainActor inference mode** for app targets that are mostly single-threaded196- **Profile before offloading** — use Instruments to find actual bottlenecks197- **Protect globals with MainActor** — global/static mutable state needs actor isolation198- **Use isolated conformances** instead of `nonisolated` workarounds or `@Sendable` wrappers199- **Migrate incrementally** — enable features one at a time in build settings200 201## Anti-Patterns to Avoid202 203- Applying `@concurrent` to every async function (most don't need background execution)204- Using `nonisolated` to suppress compiler errors without understanding isolation205- Keeping legacy `DispatchQueue` patterns when actors provide the same safety206- Skipping `model.availability` checks in concurrency-related Foundation Models code207- Fighting the compiler — if it reports a data race, the code has a real concurrency issue208- Assuming all async code runs in the background (Swift 6.2 default: stays on calling actor)209 210## When to Use211 212- All new Swift 6.2+ projects (Approachable Concurrency is the recommended default)213- Migrating existing apps from Swift 5.x or 6.0/6.1 concurrency214- Resolving data-race safety compiler errors during Xcode 26 adoption215- Building MainActor-centric app architectures (most UI apps)216- Performance optimization — offloading specific heavy computations to background