El protocolo Sendable
Marque los tipos como seguros para atravesar dominios de concurrencia.
El protocolo Sendable es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.
Qué significa Sendable
Sendable es un protocolo marcador. Un tipo que se ajusta a él garantiza que es seguro compartirlo entre dominios de concurrencia sin introducir condiciones de carrera de datos.
No tiene métodos; es una garantía de seguridad de hilos comprobada por el compilador.
protocol Sendable {}Los tipos valor suelen ser Sendable
Las estructuras y enumeraciones cuyas propiedades almacenadas son todas Sendable pueden ajustarse al protocolo automáticamente.
Como los valores se copian al pasarlos, cada tarea obtiene su propia copia independiente.
struct User: Sendable {
let id: Int
let name: String
}Conformidad implícita
Muchos tipos valor obtienen Sendable de forma implícita: estructuras y enumeraciones frozen no públicas cuyos miembros son Sendable, tuplas de tipos Sendable y metatipos.
A menudo no necesita escribir : Sendable para los tipos valor internos.
enum Direction { case north, south, east, west }
// Implicitly Sendable: no associated non-Sendable dataCuándo una estructura NO es Sendable
Si una estructura contiene una propiedad almacenada que no es Sendable, no es Sendable.
Aquí, la referencia a la clase hace accesible un estado mutable compartido, por lo que el compilador rechaza la conformidad automática.
final class Box { var value = 0 }
struct Wrapper { // not Sendable
let box: Box // class with mutable state
}Clases y Sendable
Las clases son tipos de referencia, por lo que las copias comparten la misma instancia. Una clase solo es Sendable si es final y todas sus propiedades almacenadas son inmutables y Sendable.
final class ImmutablePoint: Sendable {
let x: Double
let y: Double
init(x: Double, y: Double) { self.x = x; self.y = y }
}@unchecked Sendable
A veces sabe que una clase es segura para subprocesos (protege el estado con un bloqueo), pero el compilador no puede demostrarlo. Use @unchecked Sendable para afirmar manualmente que es segura.
Esta es una vía de escape: usted asume la responsabilidad de la corrección.
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
}
}Closures @Sendable
Las closures también pueden marcarse como @Sendable. Una closure de este tipo puede pasarse a través de límites de concurrencia, por lo que el compilador verifica que solo capture valores Sendable.
func run(_ work: @Sendable () -> Void) {
work()
}
let name = "Ada" // immutable, Sendable
run { print(name) }Se rechaza la captura de estado mutable
Una closure @Sendable no puede capturar una variable mutable, porque dos tareas podrían modificarla simultáneamente.
El compilador marca la captura que aparece a continuación.
var counter = 0
// Error: @Sendable closure captures mutable var
// run { counter += 1 }Sendable en API asíncronas
Los puntos de entrada de concurrencia requieren Sendable. Las closures de Task son @Sendable, y los valores que se pasan a otros actores deben ser Sendable.
Así es como el sistema de tipos impide que los datos no seguros para subprocesos se filtren entre tareas.
func process(_ user: User) async {
Task {
// user is Sendable, safe to capture
print(user.name)
}
}Restricciones genéricas de Sendable
Puede exigir Sendable en los genéricos. Una función que crea tareas con su argumento debería restringir ese argumento a Sendable.
func dispatch<T: Sendable>(_ value: T) {
Task { print(value) }
}Sendable frente a actor
Sendable responde a «¿es seguro pasar este valor?», mientras que un actor responde a «¿cómo protejo el estado mutable?»
Se complementan: los actores son Sendable implícitamente porque el acceso a su estado se serializa.
actor Logger { } // actors are implicitly SendableComprobación rápida: Sendable
Ponga a prueba su comprensión de la conformidad con Sendable.
Repaso: el protocolo Sendable
Sendable marca los tipos que son seguros al atravesar límites de concurrencia. Los tipos de valor inmutables obtienen la conformidad automáticamente; las clases finales e inmutables pueden obtenerla; las clases seguras para subprocesos usan @unchecked Sendable.
Las closures @Sendable solo pueden capturar valores Sendable, y las API asíncronas requieren Sendable para evitar el uso compartido no seguro. Junto con los actores, Sendable constituye la base a nivel de tipos de la seguridad de Swift frente a las carreras de datos.
Preguntas frecuentes
¿La lección «El protocolo Sendable» es gratis?
Sí — el texto completo de «El protocolo Sendable» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.
¿Qué aprenderé en «El protocolo Sendable»?
Marque los tipos como seguros para atravesar dominios de concurrencia. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «El protocolo Sendable»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- El problema de las condiciones de carrera
- El protocolo Sendable
- Aislamiento de actores y nonisolated
- Migración a la concurrencia estricta