Sendable — o que é, protocolo de segurança de threads

O que é o protocolo Sendable em Swift?

Sendable é um protocolo da biblioteca padrão Swift (SE-0302) que marca tipos seguros para transferência entre domínios de isolamento. Um domínio de isolamento significa um actor, uma tarefa Task ou um contexto @MainActor. Sendable não contém requisitos — atua como um marcador de segurança.

Por que o Sendable é necessário

Antes do Swift 5.5, os desenvolvedores podiam transferir qualquer objeto entre threads via DispatchQueue, e o compilador não verificava se era seguro. Sendable fecha essa lacuna: agora o compilador rastreia as transferências entre threads e bloqueia as inseguras. Isso torna o código concorrente mais confiável mesmo antes de ser executado.

struct UserProfile: Sendable {
    let name: String
    let age: Int
}

class NonSendableClass {
    var counter: Int = 0
}

No exemplo, UserProfile pode ser transferido com segurança entre threads porque é uma struct com propriedades constantes de tipos Sendable. NonSendableClass causará um erro de compilação ao tentar transferi-lo via await ou para um Task.

Quais tipos estão em conformidade com Sendable por padrão

Os tipos Sendable em Swift dividem-se em três categorias: tipos de valor com propriedades Sendable, classes finais com estado imutável e funções/closures marcadas com @Sendable. O compilador infere automaticamente a conformidade com Sendable para tipos de valor.

Tipos de valor e conformidade automática

Struct, enum e tupla tornam-se automaticamente Sendable se todas as suas propriedades e valores associados também forem Sendable. Esta é uma abordagem conservadora: se pelo menos uma propriedade não estiver em conformidade com Sendable, o tipo inteiro não será reconhecido como seguro.

Tipos básicos

Todos os tipos incorporados do Swift — Int, String, Double, Bool, Optional, Array, Dictionary, Set — estão em conformidade com Sendable. Isso torna a composição de tipos segura por padrão. O desenvolvedor só precisa cuidar das classes personalizadas.

Sendable e classes: @unchecked Sendable

@unchecked Sendable é um mecanismo que permite a uma classe declarar-se explicitamente como Sendable, ignorando as verificações do compilador. O desenvolvedor assume a responsabilidade pela segurança de threads dessa classe. Isso é útil para pontes Objective-C e estruturas otimizadas.

Quando usar @unchecked Sendable

@unchecked Sendable é usado quando uma classe garante internamente a segurança por meio de locks ou operações atômicas, mas o compilador não pode verificar isso estaticamente. Por exemplo, uma classe com os_unfair_lock ou pthread_mutex_t — sua segurança de threads é garantida pelo código, mas o Swift não vê isso.

final class AtomicCounter: @unchecked Sendable {
    private var value: Int = 0
    private let lock = NSLock()
    
    func increment() {
        lock.lock()
        value += 1
        lock.unlock()
    }
}

Usar @unchecked Sendable deve ser feito com cuidado. É um sinal explícito para outros desenvolvedores: «verifiquei, é seguro». Um erro na implementação pode levar a condições de corrida difíceis de encontrar. Antes de usar @unchecked, certifique-se de que o tipo realmente não pode ser reescrito como um tipo de valor.

Sendable em combinação com Actor

Actor e Sendable são dois lados da mesma moeda. Actor isola seu estado, mas para trocar dados com o mundo exterior deve retornar tipos Sendable. Se um método de actor retornar um tipo não Sendable, o compilador emite um aviso ou erro.

Transferência de dados via Sendable

Quando um actor envia dados para código externo, esses dados cruzam o limite de isolamento. Sendable garante que o destinatário possa usá-los com segurança fora do actor. O actor permanece isolado — seu estado interno não é exposto.

struct AccountSnapshot: Sendable {
    let id: UUID
    let balance: Double
    let lastUpdated: Date
}

actor BankActor {
    private var balance: Double = 0
    
    func snapshot() async -> AccountSnapshot {
        return AccountSnapshot(
            id: UUID(),
            balance: balance,
            lastUpdated: Date()
        )
    }
}

AccountSnapshot é uma struct Sendable que contém apenas propriedades let de tipos Sendable. Essa abordagem é uma boa prática para extrair dados de um actor. O snapshot do estado é transferido por valor, e o actor não perde o controle sobre seu estado.

Funções e closures Sendable

@Sendable é um atributo para funções e closures que garante que a closure não capture dados não Sendable de forma mutável. Quando uma closure é transferida para um Task ou método de actor, ela deve ser Sendable.

Verificação de captura em closures @Sendable

O compilador verifica que a closure @Sendable não captura referências mutáveis para classes. Capturar propriedades let de tipos Sendable é permitido. Capturar uma variável var de um tipo de referência causará erro porque a closure pode ser executada simultaneamente com a mutação.

func performAsync(operation: @Sendable () -> Void) {
    Task {
        await operation()
    }
}

let constant = "Safe"
var counter = 0
// counter — capturar var muta counter, erro de compilação
performAsync { // ❌ Mutação de variável capturada
    print(constant)
}

A regra é simples: uma closure @Sendable só pode capturar dados que são eles próprios Sendable e não serão mutados externamente. Para classes, é permitido capturar uma referência fraca weak self se a classe não estiver marcada como Sendable. Isso evita ciclos de retenção clássicos e condições de corrida.