Swift Academy · Aula

Migração para Concorrência Estrita

Adote gradualmente a verificação de concorrência do Swift 6.

Aula 4 de 413 etapas

Migração para Concorrência Estrita é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que é Concorrência Estrita?

A verificação de concorrência estrita faz o compilador diagnosticar cada possível corrida de dados em tempo de compilação.

No modo de linguagem Swift 6, ela vem ativada por padrão; no modo Swift 5, você a ativa gradualmente.

Os Três Níveis de Verificação

O sinalizador -strict-concurrency tem três níveis: minimal (padrão no Swift 5), targeted (verifica código que já usa concorrência) e complete (verificação completa no estilo do Swift 6).

// Build settings example
// SWIFT_STRICT_CONCURRENCY = complete

Adoção Gradual

O caminho recomendado é avançar gradualmente pelos níveis: comece em targeted, corrija os avisos e depois passe para complete antes de mudar o modo de linguagem para 6.

Isso mantém a migração administrável em bases de código grandes.

// Step 1: targeted
// Step 2: complete (warnings)
// Step 3: Swift 6 mode (errors)

Migração por Módulo

A concorrência estrita é configurada por target. Você pode migrar um módulo por vez, mantendo os outros no modo Swift 5 até que estejam prontos.

// Package.swift target
// swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]

Aviso Comum: Captura de Valor Não Sendable

O diagnóstico mais frequente é capturar um valor não Sendable em uma Task ou enviá-lo através de um limite de ator.

Corrija tornando o tipo Sendable ou copiando apenas dados Sendable.

final class Model { var name = "" }
func start(_ m: Model) {
    // Warning: non-Sendable Model captured by Task
    // Task { print(m.name) }
}

Correção com Tipos de Valor

Muitas vezes, a correção mais limpa é modelar os dados como um tipo de valor imutável, que é Sendable automaticamente.

struct Model: Sendable { let name: String }
func start(_ m: Model) {
    Task { print(m.name) } // safe now
}

Correção com @MainActor

Tipos de interface do usuário frequentemente geram avisos porque são acessados a partir de tarefas em segundo plano. Anotar o tipo com @MainActor o vincula à linha de execução principal e resolve os avisos.

@MainActor
final class ViewModel {
    var items: [String] = []
    func reload() async {
        let fetched = await load()
        items = fetched
    }
}
func load() async -> [String] { [] }

Conformidade com Sendable para Tipos Existentes

Para tipos que você controla e que já são seguros para acesso concorrente, adicione explicitamente a conformidade com Sendable ou @unchecked Sendable para eliminar os avisos de forma honesta.

import Foundation
final class Counter: @unchecked Sendable {
    private let lock = NSLock()
    private var n = 0
}

Importações com @preconcurrency

Quando uma dependência ainda não anotou sua API, @preconcurrency import relaxa a verificação desse módulo, rebaixando erros para avisos até que ele seja atualizado.

@preconcurrency import SomeLegacyFramework

Marcando Símbolos com @preconcurrency

Você também pode marcar declarações individuais com @preconcurrency, para que chamadores de código antigo não recebam erros quando você adicionar requisitos de Sendable.

@preconcurrency
func handle(_ value: Sendable) { }

Verificando a Migração

Quando a verificação complete produzir zero avisos, mude o target para o modo Swift 6, para que as garantias se tornem erros aplicados pelo compilador e não possam regredir.

// Package.swift
// .target(name: "App", swiftSettings: [.swiftLanguageMode(.v6)])

Verificação Rápida: Migração

Teste sua compreensão da migração para a concorrência estrita.

Responda na aula interativa

Recapitulação: Migrando para a Concorrência Estrita

A verificação de concorrência estrita transfere a detecção de corridas de dados para o tempo de compilação, com os níveis minimal, targeted e complete. Migre por módulo, corrija capturas não Sendable com tipos de valor, @MainActor ou conformidade honesta com Sendable, e use @preconcurrency para facilitar a interoperabilidade com dependências não migradas.

Quando complete não produzir mais avisos, ative o modo Swift 6 para consolidar as garantias.

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Migração para Concorrência Estrita” é grátis?

Sim — o texto completo de “Migração para Concorrência Estrita” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Migração para Concorrência Estrita”?

Adote gradualmente a verificação de concorrência do Swift 6. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Migração para Concorrência Estrita”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy