Acteurs et isolation des données, nonisolated
Découvrez l’isolation des acteurs : l’état est protégé derrière un actor , les accès entre acteurs nécessitent await et les membres nonisolated contournent l’isolation lorsqu’ils sont purs ou statiques.
Acteurs et isolation des données, nonisolated est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 3 leçons au total.
Ce que fournissent les acteurs
Un acteur protège son état mutable. Une seule tâche à la fois accède à l’état isolé ; les appelants externes doivent utiliser await avec ses méthodes.
- L’isolation = aucune course de données
- Les appels entre acteurs sont asynchrones
- nonisolated pour les membres purs ou statiques
Bases des acteurs
À l’intérieur de l’acteur, l’accès est direct. Depuis l’extérieur, vous devez utiliser await pour lire ou écrire l’état isolé.
actor Counter {
private var value: Int = 0 // isolated state
func increment() { value += 1 } // isolated method (async to outsiders)
func get() -> Int { value } // read isolated state
}
let c = Counter()
Task {
await c.increment()
print(await c.get()) // 1
}Garantie de sérialisation
Même si plusieurs tâches appellent l’acteur simultanément, l’acteur sérialise l’accès à son état, ce qui empêche les courses.
actor BankAccount {
private var balance: Int = 0
func deposit(_ amount: Int) { balance += amount }
func withdraw(_ amount: Int) -> Bool {
if balance >= amount { balance -= amount; return true }
return false
}
func current() -> Int { balance }
}
let acc = BankAccount()
Task {
async let a = acc.deposit(50)
async let b = acc.withdraw(20)
_ = await (a, b) // operations are serialized inside the actor
print(await acc.current()) // deterministic balance
}API nonisolated
Marquez les membres purs ou statiques avec nonisolated afin que les appelants n’aient pas besoin de await. Ces membres ne doivent pas accéder à l’état isolé.
actor Clock {
private var ticks: Int = 0
func tick() { ticks += 1 }
func read() -> Int { ticks }
// Nonisolated: safe without awaiting (pure computation / constant)
nonisolated static let format = "HH:mm:ss"
nonisolated func describeFormat() -> String {
// Cannot touch isolated state here; this is pure
return "Format: " + Self.format
}
}
let cl = Clock()
Task {
await cl.tick()
print(await cl.read()) // 1
// Nonisolated members don't require await:
print(Clock.format) // "HH:mm:ss"
print(cl.describeFormat()) // sync call
}Comprendre la réentrance
Les acteurs peuvent être réentrants : après un await dans une méthode d’acteur, d’autres messages peuvent être exécutés. Maintenez les invariants valides entre les points d’attente.
actor Logger {
private var lines: [String] = []
func log(_ s: String) async {
lines.append(s)
// Simulate an await point; actor may process other messages here (reentrant)
try? await Task.sleep(nanoseconds: 10_000_000)
lines.append("done")
}
func snapshot() -> [String] { lines }
}
let logger = Logger()
Task {
async let a = logger.log("A")
async let b = logger.log("B")
_ = await (a, b)
print(await logger.snapshot()) // order shows possible interleaving
}Bonnes pratiques
Recommandations :
- Exposez de petites méthodes asynchrones ; évitez les longues sections critiques.
- Utilisez nonisolated pour les constantes et les fonctions auxiliaires pures.
- Ne stockez pas d’état mutable partagé non-Sendable en dehors des acteurs (vous découvrirez Sendable ensuite).
Exigence d’isolation des acteurs
Vérification rapide : comment lire ou écrire l’état d’un acteur depuis l’extérieur ?
Récapitulatif
Récapitulatif : les acteurs isolent l’état mutable ; l’accès externe nécessite await. Utilisez nonisolated pour les membres purs ou statiques et concevez de courtes méthodes asynchrones afin de garantir une réentrance sûre.
Questions Fréquemment Posées
La leçon « Acteurs et isolation des données, nonisolated » est-elle gratuite ?
Oui — le texte complet de « Acteurs et isolation des données, nonisolated » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Acteurs et isolation des données, nonisolated » ?
Découvrez l’isolation des acteurs : l’état est protégé derrière un actor , les accès entre acteurs nécessitent await et les membres nonisolated contournent l’isolation lorsqu’ils sont purs ou statiqu… Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Swift Academy ?
Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.
Combien de temps prend la leçon « Acteurs et isolation des données, nonisolated » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?
Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- TaskGroup pour le parallélisme
- Acteurs et isolation des données, nonisolated
- Sendable et vérification de la sécurité des threads