0Pricing
Swift Academy · Lección

Actores: protección del estado mutable compartido

Utilice actor para serializar el acceso y prevenir carreras de datos en tiempo de compilación.

Actores: protección del estado mutable compartido es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 4 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.

Introducción

Los actores de Swift protegen el estado mutable compartido frente al acceso concurrente mediante el *aislamiento del actor*. Proporcionan concurrencia segura sin bloqueos manuales.

Definir un actor

```swift actor Counter { var count = 0 func increment() { count += 1 } func value() -> Int { count } } ```

Acceder al estado de un actor

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` Todas las llamadas entre actores son asíncronas: esperan el turno del actor.

Aislamiento de datos

```swift actor BankAccount { private var balance: Double = 0 func deposit(_ amount: Double) { balance += amount } func withdraw(_ amount: Double) throws { guard amount <= balance else { throw BankError.insufficient } balance -= amount } } ```

nonisolated

```swift actor Config { nonisolated let appName: String = "CoddyKit" // safe to access without await var settings: [String:String] = [:] } let name = Config().appName // no await needed ```

@MainActor

```swift @MainActor class ViewController { var label = UILabel() func updateText(_ text: String) { label.text = text // guaranteed on main thread } } ``` `@MainActor` es un actor especial que se ejecuta en el subproceso principal.

Requisito de Sendable

Los tipos que se pasan entre límites de actores deben cumplir con `Sendable`: ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Actor frente a Class

| Característica | Actor | Class | |---|---|---| | Seguro para la concurrencia | ✓ | ✗ | | Tipo por referencia | ✓ | ✓ | | Herencia | ✗ | ✓ | | Acceso async | ✓ | — |

Los actores no pueden producir interbloqueos

A diferencia de los bloqueos, los actores no pueden producir interbloqueos, pero pueden causar *reentrada del actor* cuando un actor espera a otro y llega una segunda llamada durante la espera.

Actores globales

```swift @globalActor struct DatabaseActor { static let shared = Actor() actor Actor {} } @DatabaseActor func save() { ... } ```

Comprobación rápida

¿Por qué el acceso externo a las propiedades de un actor debe usar `await`?

Repaso

Conceptos clave: • Los actores protegen el estado mutable: ejecutan una tarea a la vez • El acceso externo requiere `await` • `nonisolated` para miembros seguros no aislados • `@MainActor` — se ejecuta en el subproceso principal; úselo para la interfaz de usuario • Los tipos que atraviesan los límites de los actores deben ser `Sendable` ¡Curso completado! Siguiente: Genéricos avanzados.

Preguntas frecuentes

¿La lección «Actores: protección del estado mutable compartido» es gratis?

Sí — el texto completo de «Actores: protección del estado mutable compartido» 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 «Actores: protección del estado mutable compartido»?

Utilice actor para serializar el acceso y prevenir carreras de datos en tiempo de compilación. 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 4 de 4.

¿Cuánto tiempo toma la lección «Actores: protección del estado mutable compartido»?

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. Sintaxis de async/await y llamadas a funciones asíncronas
  2. Task y cancelación de tareas
  3. async let y tareas hijas concurrentes
  4. Actores: protección del estado mutable compartido
← Volver a Swift Academy