0Pricing
Swift Academy · Leçon

Acteurs : protéger l’état mutable partagé

Utiliser actor pour sérialiser les accès et empêcher les courses de données à la compilation.

Acteurs : protéger l’état mutable partagé est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Bienvenue

Les acteurs Swift protègent l’état mutable partagé contre les accès concurrents grâce à l’*isolation des acteurs*. Ils offrent une concurrence sûre sans verrous manuels.

Définir un acteur

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

Accéder à l’état d’un acteur

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` Tous les appels entre acteurs sont asynchrones — ils attendent le tour de l’acteur.

Isolation des données

```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` est un acteur spécial qui s’exécute sur le thread principal.

Exigence Sendable

Les types transmis entre les frontières d’acteurs doivent être conformes à `Sendable` : ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Acteur ou classe

| Fonctionnalité | Acteur | Classe | |---|---|---| | Sûr en contexte concurrent | ✓ | ✗ | | Type référence | ✓ | ✓ | | Héritage | ✗ | ✓ | | Accès asynchrone | ✓ | — |

Les acteurs ne peuvent pas provoquer d’interblocage

Contrairement aux verrous, les acteurs ne peuvent pas provoquer d’interblocage — mais ils peuvent entraîner une *réentrance d’acteur* lorsqu’un acteur attend un autre acteur et qu’un second appel arrive entre-temps.

Acteurs globaux

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

Vérification rapide

Pourquoi l’accès externe aux propriétés d’un acteur doit-il utiliser `await` ?

Récapitulatif

Points essentiels : • Les acteurs protègent l’état mutable — une seule tâche s’exécute à la fois • L’accès externe nécessite `await` • `nonisolated` pour les membres sûrs et non isolés • `@MainActor` — s’exécute sur le thread principal ; à utiliser pour l’interface utilisateur • Les types qui franchissent les frontières d’acteurs doivent être `Sendable` Cours terminé ! Ensuite : les génériques avancés.

Questions Fréquemment Posées

La leçon « Acteurs : protéger l’état mutable partagé » est-elle gratuite ?

Oui — le texte complet de « Acteurs : protéger l’état mutable partagé » 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 « Acteurs : protéger l’état mutable partagé » ?

Utiliser actor pour sérialiser les accès et empêcher les courses de données à la compilation. 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 4 sur 4.

Combien de temps prend la leçon « Acteurs : protéger l’état mutable partagé » ?

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

  1. Syntaxe async/await et appel de fonctions asynchrones
  2. Task et annulation de Task
  3. async let et tâches enfants concurrentes
  4. Acteurs : protéger l’état mutable partagé
← Retour à Swift Academy