Swift Academy · Leçon

Isolation des acteurs et nonisolated

Raisonnez sur les limites d’isolation.

Isolation des acteurs et nonisolated est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. 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 4 leçons au total.

Qu'est-ce que l'isolation des acteurs ?

L'isolation d'un acteur signifie que l'état mutable d'un acteur ne peut être modifié que par du code exécuté sur cet acteur.

L'environnement d'exécution sérialise les accès, de sorte que deux tâches ne modifient jamais l'état simultanément, ce qui élimine les courses de données.

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

Appeler un acteur

Depuis l'extérieur de l'acteur, l'accès aux membres isolés est asynchrone. Vous devez utiliser await, car l'appel peut être suspendu jusqu'à ce que l'acteur soit disponible.

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

Dans l'acteur : synchrone

Dans les propres méthodes de l'acteur, vous êtes déjà isolé : vous accédez donc à l'état de manière synchrone, sans await pour accéder à self.

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

Membres non isolés

Marquez un membre nonisolated lorsqu'il ne touche pas à l'état mutable. De tels membres s'exécutent de manière synchrone depuis n'importe où, sans await.

C'est idéal pour les valeurs calculées uniquement à partir de données immuables.

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

Pourquoi nonisolated est sûr

Un membre nonisolated ne peut lire qu'un état immuable (let) ou autrement transférable.

Le compilateur refuse toute tentative d'accès à un état isolé mutable depuis un contexte non isolé.

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 et les protocoles

nonisolated est essentiel lorsqu'un acteur adopte un protocole synchrone. La méthode du protocole ne peut pas être asynchrone et doit donc éviter l'état isolé.

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

Le MainActor

@MainActor est un acteur global qui isole le code sur le fil d'exécution principal. Les mises à jour de l'interface utilisateur doivent se trouver ici.

Annotez les types, les méthodes ou les propriétés pour les rattacher à l'acteur principal.

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

Passer d'un acteur à l'autre

Lorsque vous appelez un acteur depuis un autre, l'environnement d'exécution change d'exécuteur et suspend l'exécution. C'est précisément à cet endroit que await apparaît.

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
}

Réentrance des acteurs

Les acteurs sont réentrants : lorsqu'une méthode attend avec await, l'acteur peut exécuter d'autres travaux en attente avant la reprise.

L'état que vous avez lu avant un await peut avoir changé après celui-ci. Revérifiez vos hypothèses après les points de suspension.

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

Paramètres isolés

Une fonction peut recevoir un paramètre d'acteur isolated et exécuter son corps sur cet acteur sans en être un membre.

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

Acteurs globaux pour les sous-systèmes

Vous pouvez définir votre propre acteur global pour isoler tout un sous-système (par exemple, un pipeline de rendu) sur un seul exécuteur.

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

Vérification rapide : isolation

Vérifiez votre compréhension de l'isolation des acteurs.

Récapitulatif : isolation des acteurs et nonisolated

L'isolation des acteurs sérialise l'accès à l'état mutable ; les appels entre acteurs sont asynchrones et exigent await. Les membres nonisolated échappent à l'isolation, mais ne peuvent lire qu'un état immuable ou transférable, ce qui est essentiel pour la conformité aux protocoles synchrones.

@MainActor rattache le code au fil d'exécution principal, les acteurs sont réentrants (l'état peut changer entre deux await), et les acteurs globaux isolent des sous-systèmes entiers. Maîtriser ces règles est essentiel pour assurer une concurrence sûre.

Questions Fréquemment Posées

La leçon « Isolation des acteurs et nonisolated » est-elle gratuite ?

Oui — le texte complet de « Isolation des acteurs et 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 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Isolation des acteurs et nonisolated » ?

Raisonnez sur les limites d’isolation. 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 3 sur 4.

Combien de temps prend la leçon « Isolation des acteurs et 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

← Retour à Swift Academy