/* Page prose (fr) */
"OneTaskAtATime" = "# Un actor ne laisse entrer qu'une tâche à la fois\n\nD'abord, le problème une fois de plus. Voici la forme du bug du chapitre [Les dangers de la concurrence](Concurrency%20Hazards.playgroundchapter/Overview), sous sa forme la plus simple. Une simple classe contient un solde, et plein de dépôts concurrents se le disputent:\n\n```swift\nfinal class UnsafeLedger {\n    var balance = 0\n\n    func deposit(_ amount: Int) {\n        balance += amount   // read, add, write (not atomic)\n    }\n}\n```\n\nCe `balance += amount` est en réalité *trois* étapes: lire la valeur actuelle, y ajouter, la réécrire. Si deux tâches lisent `0` en même temps, elles écrivent toutes les deux `1`, et un dépôt est perdu. Exécute mille dépôts concurrents et tu obtiens rarement `1000`.\n\nEn Swift 6, si tu essaies réellement de partager ce `UnsafeLedger` entre des tâches concurrentes, **le compilateur t'arrête**: une simple classe mutable n'est pas sûre à partager, donc elle ne compilera pas. C'est le compilateur qui te pointe vers le bon outil. L'outil est un actor.\n\nUn **actor** est un type référence, comme une classe, dont l'état mutable ne peut être touché que par **une tâche à la fois**. L'actor sérialise chaque accès à son propre état, si bien que le lire-ajouter-écrire ci-dessus ne peut jamais se chevaucher. Remplace `class` par `actor` (et, tant qu'on resserre les choses, marque `balance` comme `private(set)` pour que seules les méthodes de l'actor lui-même puissent le changer; le code externe peut toujours le lire):\n\n```swift\nactor Ledger {\n    private(set) var balance = 0\n\n    func deposit(_ amount: Int) {\n        balance += amount\n    }\n}\n```\n\nC'est toute la correction. Les appels à `deposit` sont désormais sérialisés automatiquement: pendant qu'une tâche est à l'intérieur de `deposit`, toute autre tâche doit attendre son tour. Pas de file à mettre en place, rien à retenir. Martelons-le avec mille dépôts concurrents en utilisant un task group (du chapitre [Task Groups](Task%20Groups.playgroundchapter/Overview)).";
"OneTaskAtATime-2" = "**Observe l'exécution:** le solde final est **`1000`. À chaque fois.** Exécute-le encore et encore; il ne dérive jamais. Les mille dépôts ont tous atterri. Compare cela à la version avec classe, qui perd des mises à jour de façon imprévisible. L'actor a transformé une course en une garantie, et tu n'as pas écrit un seul verrou.\n\n* callout(Essaie): Monte la boucle à `1...10_000` dépôts. Le solde final sort-il toujours exactement juste à chaque exécution?\n\n> Cela diffère de la correction avec file en série plus tôt dans le livre. Là tu *choisissais* de router chaque accès à travers une file, et rien ne t'obligeait à être cohérent; un seul accès direct égaré réintroduisait la course. Un actor fait de cette protection une partie du type. Il n'y a aucun moyen d'atteindre `balance` qui contourne la sérialisation, et le compilateur le vérifie pour toi.\n\n[Précédent](@previous)  |  page 2 sur 7  |  [Suivant: Isolation d'actor](@next)";
