Sendable — qué es, protocolo de seguridad de hilos

¿Qué es el protocolo Sendable en Swift?

Sendable es un protocolo de la biblioteca estándar de Swift (SE-0302) que marca los tipos seguros para transferir entre dominios de aislamiento. Un dominio de aislamiento puede ser un actor, una tarea Task o un contexto @MainActor. Sendable no contiene requisitos — actúa como un marcador de seguridad.

¿Por qué se necesita Sendable?

Antes de Swift 5.5, los desarrolladores podían transferir cualquier objeto entre hilos a través de DispatchQueue, y el compilador no verificaba si era seguro. Sendable cierra esta brecha: ahora el compilador rastrea las transferencias entre hilos y bloquea las no seguras. Esto hace que el código concurrente sea más fiable incluso antes de ejecutarse.

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

class NonSendableClass {
    var counter: Int = 0
}

En el ejemplo, UserProfile puede transferirse de forma segura entre hilos porque es una estructura con propiedades constantes de tipos Sendable. NonSendableClass provocará un error de compilación al intentar transferirlo mediante await o a un Task.

Qué tipos cumplen con Sendable por defecto

Los tipos Sendable en Swift se dividen en tres categorías: tipos valor con propiedades Sendable, clases finales con estado inmutable y funciones/clausuras marcadas con @Sendable. El compilador infiere automáticamente la conformidad con Sendable para los tipos valor.

Tipos valor y conformidad automática

Struct, enum y tupla se vuelven automáticamente Sendable si todas sus propiedades y valores asociados también son Sendable. Este es un enfoque conservador: si al menos una propiedad no cumple con Sendable, todo el tipo no se reconocerá como seguro.

Tipos básicos

Todos los tipos incorporados de Swift — Int, String, Double, Bool, Optional, Array, Dictionary, Set — cumplen con Sendable. Esto hace que la composición de tipos sea segura por defecto. El desarrollador solo debe vigilar las clases personalizadas.

Sendable y clases: @unchecked Sendable

@unchecked Sendable es un mecanismo que permite a una clase declararse explícitamente como Sendable, omitiendo las verificaciones del compilador. El desarrollador asume la responsabilidad de la seguridad de hilos de dicha clase. Esto es útil para puentes con Objective-C y estructuras optimizadas.

Cuándo usar @unchecked Sendable

@unchecked Sendable se usa cuando una clase garantiza internamente la seguridad mediante bloqueos u operaciones atómicas, pero el compilador no puede verificarlo estáticamente. Por ejemplo, una clase con os_unfair_lock o pthread_mutex_t — su seguridad de hilos está garantizada por el código, pero Swift no lo detecta.

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 debe hacerse con cuidado. Es una señal explícita para otros desarrolladores: «lo verifiqué, esto es seguro». Un error en la implementación puede provocar condiciones de carrera difíciles de detectar. Antes de usar @unchecked, asegúrate de que el tipo realmente no pueda reescribirse como un tipo valor.

Sendable en combinación con Actor

Actor y Sendable son dos caras de la misma moneda. Actor aísla su estado, pero para intercambiar datos con el mundo exterior debe devolver tipos Sendable. Si un método de actor devuelve un tipo no Sendable, el compilador emite una advertencia o error.

Transferencia de datos mediante Sendable

Cuando un actor envía datos a código externo, estos datos cruzan el límite de aislamiento. Sendable garantiza que el destinatario pueda usarlos de forma segura fuera del actor. El actor permanece aislado — su estado interno no se expone.

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 es una estructura Sendable que contiene solo propiedades let de tipos Sendable. Este enfoque es una buena práctica para extraer datos de un actor. La instantánea del estado se transfiere por valor y el actor no pierde el control sobre su estado.

Funciones y clausuras Sendable

@Sendable es un atributo para funciones y clausuras que garantiza que la clausura no captura datos no Sendable de forma mutable. Cuando una clausura se transfiere a un Task o método de actor, debe ser Sendable.

Verificación de captura en clausuras @Sendable

El compilador verifica que la clausura @Sendable no capture referencias mutables a clases. Se permite capturar propiedades let de tipos Sendable. Capturar una variable var de un tipo referencia provocará un error porque la clausura podría ejecutarse simultáneamente con la mutación.

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

let constant = "Safe"
var counter = 0
// counter — capturar var muta counter, error de compilación
performAsync { // ❌ Mutación de variable capturada
    print(constant)
}

La regla es simple: una clausura @Sendable solo puede capturar datos que sean Sendable y que no serán mutados desde fuera. Para clases, se permite capturar una referencia débil weak self si la clase no está marcada como Sendable. Esto evita ciclos de retención clásicos y condiciones de carrera.