Especialista em Concorrência Swift

Visão Geral

Revise e corrija problemas de Concorrência Swift em bases de código Swift 6.2+ aplicando isolamento de ator, segurança Sendable e padrões de concorrência modernos com alterações mínimas de comportamento.

Quando Usar

• Quando o usuário pedir para revisar o uso de concorrência Swift ou corrigir diagnósticos do compilador.
• Quando você precisar de orientação sobre isolamento de ator, Sendable, @MainActor ou migração assíncrona.

Fluxo de Trabalho

1. Triagem do Problema

• Capture os diagnósticos exatos do compilador e o(s) símbolo(s) ofensivo(s).
• Verifique as configurações de concorrência do projeto: versão da linguagem Swift (6.2+), nível de concorrência rigoroso e se a concorrência acessível (isolamento de ator padrão / ator principal por padrão) está habilitada.
• Identifique o contexto de ator atual (@MainActor, actor, nonisolated) e se um modo de isolamento de ator padrão está habilitado.
• Confirme se o código está vinculado à UI ou se destina a ser executado fora do ator principal.

2. Aplique a Menor Correção Segura

Prefira edições que preservem o comportamento existente enquanto satisfazem a segurança contra corridas de dados.

Correções comuns:

• Tipos vinculados à UI: anote o tipo ou membros relevantes com @MainActor.
• Conformidade de protocolo em tipos do ator principal: torne a conformidade isolada (por exemplo, extension Foo: @MainActor SomeProtocol).
• Estado global/estático: proteja com @MainActor ou mova para um ator.
• Trabalho em segundo plano: mova trabalho caro para uma função assíncrona @concurrent em um tipo nonisolated ou use um actor para proteger o estado mutável.
• Erros Sendable: prefira tipos imutáveis/de valor; adicione conformidade Sendable apenas quando correto; evite @unchecked Sendable a menos que você possa provar segurança de thread.

3. Verifique a Correção

• Recompile e confirme que todos os diagnósticos de concorrência foram resolvidos sem a introdução de novos avisos.
• Execute o conjunto de testes para verificar regressões — alterações de concorrência podem introduzir problemas sutis de tempo de execução, mesmo quando a compilação está limpa.
• Se a correção apresentar novos avisos, trate cada um como uma nova triagem (retorne à etapa 1) e resolva iterativamente até que a compilação esteja limpa e os testes passem.

Exemplos

Tipo vinculado à UI — adicionando @MainActor

// Before: data-race warning because ViewModel is accessed from the main thread
// but has no actor isolation
class ViewModel: ObservableObject {
    @Published var title: String = ""
    func load() { title = "Loaded" }
}

// After: annotate the whole type so all stored state and methods are
// automatically isolated to the main actor
@MainActor
class ViewModel: ObservableObject {
    @Published var title: String = ""
    func load() { title = "Loaded" }
}

Isolamento de conformidade de protocolo

// Before: compiler error — SomeProtocol method is nonisolated but the
// conforming type is @MainActor
@MainActor
class Foo: SomeProtocol {
    func protocolMethod() { /* accesses main-actor state */ }
}

// After: scope the conformance to @MainActor so the requirement is
// satisfied inside the correct isolation context
@MainActor
extension Foo: SomeProtocol {
    func protocolMethod() { /* safely accesses main-actor state */ }
}

Trabalho em segundo plano com @concurrent

// Before: expensive computation blocks the main actor
@MainActor
func processData(_ input: [Int]) -> [Int] {
    input.map { heavyTransform($0) }   // runs on main thread
}

// After: hop off the main actor for the heavy work, then return the result
// The caller awaits the result and stays on its own actor
nonisolated func processData(_ input: [Int]) async -> [Int] {
    await Task.detached(priority: .userInitiated) {
        input.map { heavyTransform($0) }
    }.value
}

// Or, using a @concurrent async function (Swift 6.2+):
@concurrent
func processData(_ input: [Int]) async -> [Int] {
    input.map { heavyTransform($0) }
}

Material de Referência

• Veja references/swift-6-2-concurrency.md para alterações, padrões e exemplos do Swift 6.2.
• Veja references/approachable-concurrency.md quando o projeto estiver optado pelo modo de concorrência acessível.
• Veja references/swiftui-concurrency-tour-wwdc.md para orientação de concorrência específica do SwiftUI.

Limitações

• Use esta habilidade apenas quando a tarefa corresponder claramente ao escopo descrito acima.
• Não trate a saída como um substituto para validação específica do ambiente, testes ou revisão especializada.
• Pare e peça esclarecimentos se os inputs, permissões, limites de segurança ou critérios de sucesso necessários estiverem faltando.