Swift 6.2 可接近的并発性

Swift 6.2 並行性モデルを採用するパターン。コードはデフォルトで単一スレッド上で実行され、並行性は明示的に導入されます。パフォーマンスを犠牲にすることなく、一般的なデータ競合エラーを排除します。

いつ有効にするか

• Swift 5.x または 6.0/6.1 プロジェクトを Swift 6.2 に移行
• データ競合安全コンパイラエラーを解決
• MainActor ベースのアプリケーションアーキテクチャを設計
• CPU 集約的な作業をバックグラウンドスレッドにオフロード
• MainActor 分離されたタイプにプロトコル一貫性を実装
• Xcode 26 で「可接近的な並行性」ビルド設定を有効化

コア問題: 暗黙的なバックグラウンド オフロード

Swift 6.1 以前では、非同期関数が暗黙的にバックグラウンドスレッドにオフロードされ、一見安全なコードでもデータ競合エラーが発生する可能性がありました:

// Swift 6.1: ERROR
@MainActor
final class StickerModel {
    let photoProcessor = PhotoProcessor()

    func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
        guard let data = try await item.loadTransferable(type: Data.self) else { return nil }

        // Error: Sending 'self.photoProcessor' risks causing data races
        return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
    }
}

Swift 6.2 はこの問題を修正します: 非同期関数はデフォルトで呼び出し元が属する actor 上に留まります。

// Swift 6.2: OK — async stays on MainActor, no data race
@MainActor
final class StickerModel {
    let photoProcessor = PhotoProcessor()

    func extractSticker(_ item: PhotosPickerItem) async throws -> Sticker? {
        guard let data = try await item.loadTransferable(type: Data.self) else { return nil }
        return await photoProcessor.extractSticker(data: data, with: item.itemIdentifier)
    }
}

コア パターン — 分離された一貫性

MainActor タイプは、非分離プロトコルに安全に準拠できるようになりました:

protocol Exportable {
    func export()
}

// Swift 6.1: ERROR — crosses into main actor-isolated code
// Swift 6.2: OK with isolated conformance
extension StickerModel: @MainActor Exportable {
    func export() {
        photoProcessor.exportAsPNG()
    }
}

コンパイラは、この一貫性がメインアクター上でのみ使用されることを保証します:

// OK — ImageExporter is also @MainActor
@MainActor
struct ImageExporter {
    var items: [any Exportable]

    mutating func add(_ item: StickerModel) {
        items.append(item)  // Safe: same actor isolation
    }
}

// ERROR — nonisolated context can't use MainActor conformance
nonisolated struct ImageExporter {
    var items: [any Exportable]

    mutating func add(_ item: StickerModel) {
        items.append(item)  // Error: Main actor-isolated conformance cannot be used here
    }
}

コア パターン — グローバルおよびスタティック変数

MainActor を使用してグローバル/スタティック状態を保護:

// Swift 6.1: ERROR — non-Sendable type may have shared mutable state
final class StickerLibrary {
    static let shared: StickerLibrary = .init()  // Error
}

// Fix: Annotate with @MainActor
@MainActor
final class StickerLibrary {
    static let shared: StickerLibrary = .init()  // OK
}

MainActor デフォルト推論パターン

Swift 6.2 は、手動でのアノテーションなしに MainActor をデフォルトで推論するパターンを導入します:

// With MainActor default inference enabled:
final class StickerLibrary {
    static let shared: StickerLibrary = .init()  // Implicitly @MainActor
}

final class StickerModel {
    let photoProcessor: PhotoProcessor
    var selection: [PhotosPickerItem]  // Implicitly @MainActor
}

extension StickerModel: Exportable {  // Implicitly @MainActor conformance
    func export() {
        photoProcessor.exportAsPNG()
    }
}

このパターンはオプトインであり、アプリケーション、スクリプト、および他の実行可能ターゲット向けに推奨されます。

コア パターン — @concurrent でバックグラウンド作業を実行

真の並行性が必要な場合、@concurrent を使用して明示的にオフロード:

重要: このサンプルは「可接近的な並行性」ビルド設定を有効にする必要があります — SE-0466 (MainActor デフォルト分離) および SE-0461 (デフォルト nonisolated nonisolated nonSendable)。これらの設定を有効にすると、extractSticker は呼び出し元の actor 上に留まり、可変状態へのアクセスが安全になります。これらの設定なしでは、このコードにはデータ競合があります — コンパイラはそれをフラグします。

nonisolated final class PhotoProcessor {
    private var cachedStickers: [String: Sticker] = [:]

    func extractSticker(data: Data, with id: String) async -> Sticker {
        if let sticker = cachedStickers[id] {
            return sticker
        }

        let sticker = await Self.extractSubject(from: data)
        cachedStickers[id] = sticker
        return sticker
    }

    // Offload expensive work to concurrent thread pool
    @concurrent
    static func extractSubject(from data: Data) async -> Sticker { /* ... */ }
}

// Callers must await
let processor = PhotoProcessor()
processedPhotos[item.id] = await processor.extractSticker(data: data, with: item.id)

@concurrent を使用するには:

1. 含まれるタイプを nonisolated でマーク
2. 関数に @concurrent を追加
3. 関数がまだ非同期でない場合は async を追加
4. 呼び出しポイントに await を追加

主要な設計上の決定

決定	理由
デフォルトで単一スレッド	最も自然なコードはデータ競合がない; 並行性はオプトイン
非同期関数は呼び出し元の actor 上に留まる	データ競合エラーを引き起こす暗黙的なオフロードを排除
分離された一貫性	MainActor タイプは安全でない回避策なしでプロトコルに準拠できる
@concurrent 明示的なオプトイン	バックグラウンド実行は意図的なパフォーマンス選択であり、偶然ではない
MainActor デフォルト推論	アプリケーションターゲット内の定型的な @MainActor アノテーションを減らす
オプトイン採用	非破壊的な移行パス — 段階的に機能を有効化

移行手順

1. Xcode で有効化: ビルド設定の Swift Compiler > Concurrency セクション内
2. SPM で有効化: パッケージマニフェストで SwiftSettings API を使用
3. 移行ツールを使用: swift.org/migration を通じた自動コード変更
4. MainActor デフォルトから開始: アプリケーションターゲットの推論モードを有効化
5. 必要な場所に @concurrent を追加: 最初にパフォーマンス分析を実行してから、ホットパスをオフロード
6. 徹底的にテスト: データ競合の問題はコンパイル時エラーになります

ベストプラクティス

• MainActor から開始 — 最初に単一スレッドコードを記述し、後で最適化
• CPU 集約的な作業にのみ @concurrent を使用 — 画像処理、圧縮、複雑な計算
• 主にシングルスレッドなアプリケーションターゲットで MainActor 推論モードを有効化
• オフロード前にパフォーマンス分析を実行 — Instruments を使用して実際のボトルネックを特定
• グローバル変数を MainActor で保護 — グローバル/スタティック可変状態は actor 分離が必要
• nonisolated の回避策または @Sendable ラッパーではなく、分離された一貫性を使用
• 段階的な移行 — ビルド設定で一度に 1 つの機能を有効化

避けるべきアンチパターン

• すべての非同期関数に @concurrent を適用 (ほとんどはバックグラウンド実行が不要)
• 分離を理解しないまま nonisolated を使用してコンパイラエラーを抑制
• actor が同じセキュリティを提供している場合に、従来の DispatchQueue パターンを保持
• 並行性関連の Foundation Models コード内で model.availability チェックをスキップ
• コンパイラに対抗 — データ競合を報告する場合、コードに本当の並行性の問題がある
• すべての非同期コードがバックグラウンドで実行されると仮定 (Swift 6.2 デフォルト: 呼び出し元の actor 上に留まる)

いつ使用するか

• すべての新しい Swift 6.2+ プロジェクト (「可接近的な並行性」は推奨デフォルト)
• Swift 5.x または 6.0/6.1 並行性から既存アプリケーションを移行
• Xcode 26 の採用中にデータ競合安全コンパイラエラーを解決
• MainActor 中心のアプリケーションアーキテクチャを構築 (ほとんどの UI アプリケーション)
• パフォーマンス最適化 — 特定の繁重な計算をバックグラウンドにオフロード