0Pricing
Swift Academy · Lezione

Actor: proteggere lo stato mutabile condiviso

Utilizzare actor per serializzare l’accesso e prevenire le race condition in fase di compilazione.

Actor: proteggere lo stato mutabile condiviso è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Introduzione

Gli actor di Swift proteggono lo stato mutabile condiviso dagli accessi concorrenti usando l'*isolamento degli actor*. Offrono concorrenza sicura senza lock manuali.

Definire un actor

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

Accedere allo stato di un actor

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` Tutte le chiamate tra actor sono asincrone: attendono il turno dell'actor.

Isolamento dei dati

```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` è un actor speciale che viene eseguito sul thread principale.

Requisito Sendable

I tipi passati oltre i confini degli actor devono essere conformi a `Sendable`: ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Actor e Class

| Caratteristica | Actor | Class | |---|---|---| | Sicuro rispetto alla concorrenza | ✓ | ✗ | | Tipo riferimento | ✓ | ✓ | | Ereditarietà | ✗ | ✓ | | Accesso asincrono | ✓ | — |

Gli actor non possono entrare in deadlock

A differenza dei lock, gli actor non possono entrare in deadlock, ma possono causare *rientranza dell'actor* quando un actor attende un altro actor e nel frattempo arriva una seconda chiamata.

Actor globali

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

Verifica rapida

Perché l'accesso esterno alle proprietà di un actor deve usare `await`?

Riepilogo

Concetti chiave: • Gli actor proteggono lo stato mutabile: viene eseguito un solo task alla volta • L'accesso esterno richiede `await` • `nonisolated` per i membri sicuri e non isolati • `@MainActor` — viene eseguito sul thread principale; lo usi per l'interfaccia utente • I tipi che attraversano i confini degli actor devono essere `Sendable` Corso completato! Prossimo argomento: Generics avanzati.

Domande Frequenti

La lezione «Actor: proteggere lo stato mutabile condiviso» è gratuita?

Sì — il testo completo di «Actor: proteggere lo stato mutabile condiviso» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Actor: proteggere lo stato mutabile condiviso»?

Utilizzare actor per serializzare l’accesso e prevenire le race condition in fase di compilazione. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Actor: proteggere lo stato mutabile condiviso»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Sintassi async/await e chiamata di funzioni asincrone
  2. Task e cancellazione dei task
  3. async let e task figli concorrenti
  4. Actor: proteggere lo stato mutabile condiviso
← Torna a Swift Academy