Isolamento degli actor e nonisolated
Ragioni sui confini dell’isolamento.
Isolamento degli actor e nonisolated è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 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.
Che cos'è l'isolamento degli actor?
L'isolamento degli actor significa che lo stato mutabile di un actor può essere modificato solo dal codice in esecuzione su quell'actor.
Il runtime serializza l'accesso, così due task non modificano mai lo stato contemporaneamente, eliminando le data race.
actor Counter {
private var value = 0
func increment() { value += 1 }
}Chiamare un actor dall'esterno
Dall'esterno dell'actor, l'accesso ai membri isolati è asincrono. Dovete usare await, perché la chiamata potrebbe sospendersi finché l'actor non è libero.
let counter = Counter()
func useCounter() async {
await counter.increment()
}Dentro l'actor: sincrono
All'interno dei metodi dell'actor siete già in un contesto isolato, quindi accedete allo stato in modo sincrono: per self non è necessario await.
actor Counter {
private var value = 0
func incrementTwice() {
value += 1 // synchronous: already isolated
value += 1
}
}Membri nonisolated
Contrassegnate un membro con nonisolated quando non accede allo stato mutabile. Questi membri vengono eseguiti in modo sincrono da qualsiasi contesto, senza await.
È ideale per i valori calcolati costruiti solo a partire da dati immutabili.
actor User {
let id: Int
var sessionCount = 0
init(id: Int) { self.id = id }
nonisolated var label: String { "User #\(id)" }
}Perché nonisolated è sicuro
Un membro nonisolated può leggere solo stato immutabile (let) o comunque Sendable.
Il compilatore rifiuta qualsiasi tentativo di accedere allo stato mutabile isolato da un contesto 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 e i protocolli
nonisolated è essenziale quando un actor adotta un protocollo sincrono. Il metodo del protocollo non può essere async, quindi deve evitare lo stato isolato.
actor Item: CustomStringConvertible {
let name: String
init(name: String) { self.name = name }
nonisolated var description: String { "Item: \(name)" }
}Il MainActor
@MainActor è un actor globale che isola il codice nel thread principale. Gli aggiornamenti dell'interfaccia utente devono essere eseguiti qui.
Annotate tipi, metodi o proprietà per vincolarli al main actor.
@MainActor
final class ViewModel {
var title = "Hello"
func refresh() { title = "Updated" }
}Passare da un actor all'altro
Quando chiamate un actor da un altro, il runtime passa da un executor all'altro e sospende l'esecuzione. È esattamente durante questa sospensione che compare 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
}Rientranza degli actor
Gli actor sono rientranti: quando un metodo esegue un await, l'actor può elaborare altro lavoro in coda prima che l'await riprenda l'esecuzione.
Lo stato letto prima di un await potrebbe essere cambiato dopo di esso. Verificate nuovamente le vostre ipotesi dopo i punti di sospensione.
actor Store {
var ready = false
func prepare() async {
ready = false
await Task.yield() // other calls may run here
ready = true
}
}Parametri isolated
Una funzione può accettare un parametro actor isolated ed eseguire il proprio corpo su quell'actor senza esserne un membro.
func bump(on counter: isolated Counter) {
// runs isolated to counter; synchronous access
}Actor globali per i sottosistemi
Potete definire un actor globale personalizzato per isolare un intero sottosistema (ad esempio, una pipeline di rendering) su un singolo executor.
@globalActor
actor RenderActor {
static let shared = RenderActor()
}
@RenderActor func draw() { }Verifica rapida: isolamento
Verificate la vostra comprensione dell'isolamento degli actor.
Riepilogo: isolamento degli actor e nonisolated
L'isolamento degli actor serializza l'accesso allo stato mutabile; le chiamate tra actor sono asincrone e richiedono await. I membri nonisolated rinunciano all'isolamento, ma possono leggere solo stato immutabile o Sendable, una caratteristica essenziale per la conformità ai protocolli sincroni.
@MainActor vincola il codice al thread principale, gli actor sono rientranti (lo stato può cambiare durante un await) e gli actor globali isolano interi sottosistemi. Padroneggiare queste regole è fondamentale per ottenere una concorrenza sicura.
Domande Frequenti
La lezione «Isolamento degli actor e nonisolated» è gratuita?
Sì — il testo completo di «Isolamento degli actor e nonisolated» è 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 «Isolamento degli actor e nonisolated»?
Ragioni sui confini dell’isolamento. 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 3 di 4.
Quanto tempo richiede la lezione «Isolamento degli actor e nonisolated»?
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
- Il problema delle data race
- Il protocollo Sendable
- Isolamento degli actor e nonisolated
- Migrazione alla concorrenza rigorosa