Swift Academy · Lección

Aislamiento de actores y nonisolated

Aprenda a razonar sobre los límites de aislamiento.

Lección 3 de 413 pasos

Aislamiento de actores y nonisolated es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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é es el aislamiento de actores?

El aislamiento de actores significa que el estado mutable de un actor solo puede ser manipulado por código que se ejecuta en ese actor.

El entorno de ejecución serializa el acceso para que dos tareas nunca modifiquen el estado simultáneamente, eliminando las carreras de datos.

actor Counter {
    private var value = 0
    func increment() { value += 1 }
}

Llamar a un actor

Desde fuera del actor, acceder a miembros aislados es asíncrono. Debe usar await porque la llamada puede suspenderse hasta que el actor esté disponible.

let counter = Counter()
func useCounter() async {
    await counter.increment()
}

Dentro del actor: síncrono

Dentro de los propios métodos del actor, ya está aislado, por lo que accede al estado de forma síncrona; no necesita await para self.

actor Counter {
    private var value = 0
    func incrementTwice() {
        value += 1 // synchronous: already isolated
        value += 1
    }
}

Miembros nonisolated

Marque un miembro como nonisolated cuando no acceda al estado mutable. Estos miembros se ejecutan de forma síncrona desde cualquier lugar, sin await.

Esto es ideal para valores calculados a partir únicamente de datos inmutables.

actor User {
    let id: Int
    var sessionCount = 0
    init(id: Int) { self.id = id }
    nonisolated var label: String { "User #\(id)" }
}

Por qué nonisolated es seguro

Un miembro nonisolated solo puede leer estado inmutable (let) o estado que sea Sendable.

El compilador rechaza cualquier intento de acceder a estado mutable aislado desde un contexto nonisolated.

actor User {
    let id: Int
    var sessionCount = 0
    init(id: Int) { self.id = id }
    // Error: cannot read mutable sessionCount here
    // nonisolated var bad: Int { sessionCount }
}

nonisolated y los protocolos

nonisolated es esencial cuando un actor adopta un protocolo síncrono. El método del protocolo no puede ser asíncrono, por lo que debe evitar el estado aislado.

actor Item: CustomStringConvertible {
    let name: String
    init(name: String) { self.name = name }
    nonisolated var description: String { "Item: \(name)" }
}

MainActor

@MainActor es un actor global que aísla el código en el hilo principal. Las actualizaciones de la interfaz de usuario deben realizarse aquí.

Anote tipos, métodos o propiedades para vincularlos al actor principal.

@MainActor
final class ViewModel {
    var title = "Hello"
    func refresh() { title = "Updated" }
}

Cambiar de un actor a otro

Cuando llama de un actor a otro, el entorno de ejecución cambia de ejecutor y suspende la ejecución. Esa suspensión es exactamente donde aparece await.

actor Database { func load() -> Int { 42 } }
@MainActor
func show(_ db: Database) async {
    let v = await db.load() // hop to db actor
    print(v)               // hop back to main
}

Reentrancia de los actores

Los actores son reentrantes: cuando un método espera, el actor puede ejecutar otro trabajo encolado antes de reanudar la espera.

El estado que leyó antes de un await puede haber cambiado después. Vuelva a comprobar sus suposiciones tras los puntos de suspensión.

actor Store {
    var ready = false
    func prepare() async {
        ready = false
        await Task.yield() // other calls may run here
        ready = true
    }
}

Parámetros isolated

Una función puede aceptar un parámetro de actor isolated y ejecutar su cuerpo en ese actor sin ser miembro de él.

func bump(on counter: isolated Counter) {
    // runs isolated to counter; synchronous access
}

Actores globales para subsistemas

Puede definir su propio actor global para aislar todo un subsistema (por ejemplo, una canalización de renderizado) en un único ejecutor.

@globalActor
actor RenderActor {
    static let shared = RenderActor()
}
@RenderActor func draw() { }

Comprobación rápida: aislamiento

Ponga a prueba su comprensión del aislamiento de actores.

Repaso: aislamiento de actores y nonisolated

El aislamiento de actores serializa el acceso al estado mutable; las llamadas entre actores son asíncronas y requieren await. Los miembros nonisolated omiten el aislamiento, pero solo pueden leer estado inmutable o Sendable, algo fundamental para la conformidad con protocolos síncronos.

@MainActor vincula el código al hilo principal, los actores son reentrantes (el estado puede cambiar a través de await) y los actores globales aíslan subsistemas completos. Dominar estas reglas es la base de la concurrencia segura.

Gratis para empezar

Aprende Swift con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
122
Lecciones
409

Preguntas frecuentes

¿La lección «Aislamiento de actores y nonisolated» es gratis?

Sí — el texto completo de «Aislamiento de actores y nonisolated» 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 «Aislamiento de actores y nonisolated»?

Aprenda a razonar sobre los límites de aislamiento. 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 3 de 4.

¿Cuánto tiempo toma la lección «Aislamiento de actores y nonisolated»?

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

  1. El problema de las condiciones de carrera
  2. El protocolo Sendable
  3. Aislamiento de actores y nonisolated
  4. Migración a la concurrencia estricta
← Volver a Swift Academy