Swift Academy · Aula

O Protocolo Sendable

Marque tipos como seguros para atravessar domínios de concorrência.

O Protocolo Sendable é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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 Sendable significa

Sendable é um protocolo marcador. Um tipo que está em conformidade promete ser seguro para compartilhar entre domínios de concorrência sem introduzir condições de corrida de dados.

Ele não tem métodos; é uma garantia de segurança de linhas de execução verificada pelo compilador.

protocol Sendable {}

Tipos de valor geralmente são Sendable

Estruturas e enumerações cujas propriedades armazenadas são todas Sendable podem estar em conformidade automaticamente.

Como os valores são copiados quando passados, cada tarefa recebe sua própria cópia independente.

struct User: Sendable {
    let id: Int
    let name: String
}

Conformidade implícita

Muitos tipos de valor recebem Sendable de forma implícita: estruturas e enumerações congeladas não públicas com membros Sendable, tuplas de tipos Sendable e metatipos.

Frequentemente, você nem precisa escrever : Sendable para tipos de valor internos.

enum Direction { case north, south, east, west }
// Implicitly Sendable: no associated non-Sendable data

Quando uma estrutura é NOT Sendable

Se uma estrutura armazenar uma propriedade não Sendable, ela não será Sendable.

Aqui, a referência à classe torna o estado mutável compartilhado acessível, portanto o compilador recusa a conformidade automática.

final class Box { var value = 0 }
struct Wrapper { // not Sendable
    let box: Box // class with mutable state
}

Classes e Sendable

Classes são tipos de referência, portanto as cópias compartilham a mesma instância. Uma classe só é Sendable se for final e todas as suas propriedades armazenadas forem imutáveis e Sendable.

final class ImmutablePoint: Sendable {
    let x: Double
    let y: Double
    init(x: Double, y: Double) { self.x = x; self.y = y }
}

@unchecked Sendable

Às vezes, você sabe que uma classe é segura para acesso concorrente (ela protege o estado com um bloqueio), mas o compilador não consegue provar isso. Use @unchecked Sendable para afirmar manualmente que ela é segura.

Este é um recurso de escape: você assume a responsabilidade pela correção.

import Foundation
final class Cache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Int] = [:]
    func set(_ k: String, _ v: Int) {
        lock.lock(); defer { lock.unlock() }
        storage[k] = v
    }
}

Funções de fechamento com @Sendable

Funções de fechamento também podem ser marcadas com @Sendable. Uma função de fechamento assim pode ser passada através de limites de concorrência, portanto o compilador verifica se ela captura apenas valores Sendable.

func run(_ work: @Sendable () -> Void) {
    work()
}
let name = "Ada" // immutable, Sendable
run { print(name) }

A Captura de Estado Mutável é Rejeitada

Uma função de fechamento @Sendable não pode capturar uma variável mutável, pois duas tarefas poderiam modificá-la simultaneamente.

O compilador sinaliza a captura abaixo.

var counter = 0
// Error: @Sendable closure captures mutable var
// run { counter += 1 }

Sendable em APIs Assíncronas

Pontos de entrada da concorrência exigem Sendable. Funções de fechamento de Task são @Sendable, e os valores passados para outros atores precisam ser Sendable.

É assim que o sistema de tipos impede que dados não seguros para acesso concorrente vazem entre tarefas.

func process(_ user: User) async {
    Task {
        // user is Sendable, safe to capture
        print(user.name)
    }
}

Restrições Genéricas de Sendable

Você pode exigir Sendable em tipos genéricos. Uma função que cria tarefas com seu argumento deve restringir esse argumento a Sendable.

func dispatch<T: Sendable>(_ value: T) {
    Task { print(value) }
}

Sendable versus Ator

Sendable responde a "este valor pode ser passado com segurança?", enquanto um actor responde a "como protejo o estado mutável?"

Eles se combinam: atores são implicitamente Sendable, pois o acesso ao estado deles é serializado.

actor Logger { } // actors are implicitly Sendable

Verificação Rápida: Sendable

Teste sua compreensão da conformidade com Sendable.

Recapitulação: o Protocolo Sendable

Sendable marca os tipos que podem atravessar limites de concorrência com segurança. Tipos de valor imutáveis obtêm conformidade automaticamente; classes finais imutáveis podem obter conformidade; classes seguras para acesso concorrente usam @unchecked Sendable.

Funções de fechamento @Sendable só podem capturar valores Sendable, e APIs assíncronas exigem Sendable para impedir o compartilhamento inseguro. Junto com os atores, Sendable forma a base no nível do sistema de tipos para a segurança do Swift contra corridas de dados.

Perguntas Frequentes

A aula “O Protocolo Sendable” é grátis?

Sim — o texto completo de “O Protocolo Sendable” é 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 “O Protocolo Sendable”?

Marque tipos como seguros para atravessar domínios de concorrência. 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 2 de 4.

Quanto tempo leva a aula “O Protocolo Sendable”?

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