Swift 6.2 Concorrência Acessível

Padrões para adotar o modelo de concorrência do Swift 6.2, onde o código é executado em um único thread por padrão e a concorrência é introduzida explicitamente. Elimina erros comuns de data-race sem sacrificar o desempenho.

Quando Ativar

• Migrando projetos Swift 5.x ou 6.0/6.1 para Swift 6.2
• Resolvendo erros do compilador de segurança de data-race
• Projetando arquitetura de aplicativos baseada em MainActor
• Descarregando trabalho intensivo de CPU para threads em segundo plano
• Implementando conformidades de protocolo em tipos isolados por MainActor
• Habilitando as configurações de compilação de Concorrência Acessível no Xcode 26

Problema Central: Descarregamento Implícito em Segundo Plano

No Swift 6.1 e anteriores, funções assíncronas podiam ser descarregadas implicitamente para threads em segundo plano, causando erros de data-race mesmo em código aparentemente seguro:

// 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)
    }
}

O Swift 6.2 corrige isso: funções assíncronas permanecem no ator chamador por padrão.

// 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)
    }
}

Padrão Central — Conformidades Isoladas

Tipos MainActor agora podem conformar-se a protocolos não isolados com segurança:

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()
    }
}

O compilador garante que a conformidade só seja usada no ator principal:

// 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
    }
}

Padrão Central — Variáveis Globais e Estáticas

Proteja estado global/estático com 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
}

Modo de Inferência Padrão do MainActor

O Swift 6.2 introduz um modo onde o MainActor é inferido por padrão — nenhuma anotação manual é necessária:

// 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()
    }
}

Este modo é opt-in e recomendado para aplicativos, scripts e outros destinos executáveis.

Padrão Central — @concurrent para Trabalho em Segundo Plano

Quando você precisar de paralelismo real, descarregue explicitamente com @concurrent:

Importante: Este exemplo requer as configurações de compilação de Concorrência Acessível — SE-0466 (isolamento padrão do MainActor) e SE-0461 (NonisolatedNonsendingByDefault). Com essas configurações habilitadas, extractSticker permanece no ator do chamador, tornando o acesso a estado mutável seguro. Sem essas configurações, este código tem um data race — o compilador o sinalizará.

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

…