S’il y a bien un type de bug que tous les développeurs redoutent, ce sont les data races. Deux threads accèdent simultanément à une même ressource : l’un écrit une valeur pendant que l’autre essaie de la lire, et le résultat est imprévisible.
Avec Swift 6, Apple change la donne : grâce à Swift Concurrency et au mode de vérification stricte, la sécurité de la concurrence n’est plus une affaire de convention, elle est garantie par le compilateur.
En bref :
- Data race safety : en mode Swift 6, un risque de data race détecté devient une erreur de compilation, et non plus un simple warning.
- Isolation regions : le compilateur analyse plus finement le flux des valeurs et produit beaucoup moins de faux positifs que Swift 5.
- Migration progressive : on passe d’abord par Swift 5.10 avec strict-concurrency=complete, puis on migre module par module.
- Swift 6.2 : isolation par défaut sur le MainActor et nouvel attribut @concurrent pour rendre la concurrence plus lisible.
Data race : un bug difficile à reproduire et à corriger
Contrairement à une erreur de logique classique qui se manifeste de façon reproductible, un data race dépend du contexte et de l’ordre exact d’exécution des threads. Il peut donc ne jamais apparaître en développement, puis se déclencher aléatoirement en production, sur une action spécifique d’un utilisateur dans un contexte bien précis.
Ce type de bug peut engendrer plusieurs problèmes, allant d’un simple comportement inattendu, comme l’affichage d’une valeur incorrecte, jusqu’à une erreur entraînant le crash de l’application. Pire encore, un data race peut être totalement invisible et provoquer des corruptions de données avec des incohérences d’écriture.
Ces race conditions sont difficiles à reproduire, difficiles à déboguer et potentiellement très impactantes en production. Elles peuvent également se manifester dans une partie du code complètement différente de l’origine réelle du bug.
Les développeurs mobiles sont particulièrement exposés à ce problème. Le main thread gère généralement l’interface, pendant que les tâches réseau ou de traitement de données s’exécutent en arrière-plan. Jusqu’ici, gérer correctement cette concurrence demandait beaucoup de rigueur dans la conception d’une application. Swift 6 introduit plusieurs outils pour contrer ce type de bugs directement à la compilation.
Qu’est-ce que Swift Concurrency ? Async/await, actor et structured concurrency
Swift Concurrency est le modèle de concurrence intégré au langage Swift. Il a été introduit avec Swift 5.5, présenté lors de la WWDC 2021, et repose sur plusieurs briques :

- async / await pour écrire du code asynchrone de façon linéaire, sans enchaîner les closures et les completion handlers ;
- les tasks (Task, Task.detached, task groups) pour lancer et organiser des traitements concurrents : c’est la structured concurrency ;
- les actors, dont le MainActor, pour protéger un état partagé en garantissant qu’un seul contexte y accède à la fois ;
- le protocole Sendable, qui indique qu’un type peut être transmis sans risque d’un contexte d’isolation à un autre.
Avant Swift Concurrency, le code asynchrone reposait principalement sur DispatchQueue.global(), les closures et les completion handlers. Cette approche fonctionnait, mais rien n’empêchait deux threads de modifier le même état au même moment : la protection contre les race conditions reposait entièrement sur la discipline des développeurs. Avec les fonctions async, les actors et le MainActor, c’est désormais le langage qui encadre l’accès à l’état partagé.
Swift 6, sorti en septembre 2024, s’appuie sur ces briques pour rendre la vérification des data races obligatoire dans le mode de langage Swift 6.
Data race safety : ce que change le strict concurrency de Swift 6
Avec Swift 6, Apple introduit la Data Race Safety : le compilateur intègre désormais une vérification complète de la concurrence (strict concurrency checking). Concrètement, si votre code tente de capturer un type non-Sendable dans une closure détachée, la compilation échoue. Il ne s’agit plus d’un warning, mais bien d’une erreur bloquante.

Exemple : un ViewModel muté depuis une Task détachée
Un cas qui arrive régulièrement lors du développement d’applications avec Swift est celui d’un ViewModel isolé sur le MainActor qui tente de muter une de ses propriétés depuis une Task détachée de tout contexte, et donc non isolée.
Précision : Task ou Task.detached ? Une Task hérite de l’isolation de l’acteur courant et reste donc sûre. Dans ce contexte, la Task reste isolée dans le contexte de la classe ViewModel, soit @MainActor. En utilisant Task.detached, on se libère de toute isolation : c’est à ce moment que des problèmes peuvent apparaître et que Swift 6 bloque la compilation.
Avant Swift 6, un warning serait apparu mais la compilation aurait quand même réussi. Avec Swift 6, la compilation est bloquée pour éviter toute erreur de logique liée à la concurrence.
La solution consiste ici à définir un actor dédié afin d’isoler la mutation et ainsi éviter tout problème de data race.
Moins de faux positifs grâce aux isolation regions
Swift 5 embarquait déjà un système de warnings pour signaler les portions de code pouvant entraîner des bugs de concurrence. Cependant, il était fréquent d’obtenir des warnings sur des portions de code parfaitement sûres, qui n’avaient aucune chance d’introduire des bugs, notamment avec SwiftUI qui utilise énormément la concurrence en interne. Le résultat était souvent contre-productif : à force de voir des warnings sur du code sûr, les développeurs finissaient par y prêter moins d’attention et par les ignorer, quitte à passer à côté d’un vrai problème.
Swift 6 introduit la notion d’isolation regions : le compilateur est capable de déterminer qu’une valeur n’est jamais lue ou modifiée depuis deux contextes simultanément. Au moment de la compilation, chaque valeur se voit attribuer une isolation region, c’est-à-dire un groupe de valeurs qui peuvent potentiellement s’influencer mutuellement. Le compilateur trace ensuite chaque changement dans ces groupes de valeurs. Si, au moment d’un transfert, il détermine que la région source n’est plus accessible depuis son contexte d’origine, le transfert est autorisé, même pour une valeur de type non-Sendable.
Comment migrer un projet vers Swift 6 ?
La migration ne se fait pas de manière automatique. Basculer un projet existant vers Swift 6 peut générer de nombreuses erreurs selon la façon dont la concurrence était gérée. Apple a anticipé ce problème et permet de migrer les projets module par module, afin d’étaler la migration sans bloquer un projet complet.

La méthode conseillée pour migrer un projet existant est la suivante :
- Passer à Swift 5.10 en activant le flag strict-concurrency=complete : le compilateur émet des warnings aux endroits qui deviendront des erreurs bloquantes en Swift 6.
- Corriger ces warnings, module par module, en s’aidant de l’outil de migration intégré à Xcode, qui identifie les incompatibilités les plus courantes et propose des corrections. Il ne fait pas tout, mais permet de repérer rapidement les zones à corriger. Pour les API encore basées sur des completion handlers, les continuations (withCheckedContinuation) permettent d’exposer une version async sans tout réécrire.
- Activer le mode de langage Swift 6 une fois les warnings résolus.
Cette migration reste une charge de travail importante, mais elle découle en réalité d’une dette technique déjà présente, bien qu’invisible, dans les projets. Pour aller plus loin, le guide de migration officiel vers Swift 6 détaille chaque étape.
Swift 6.2 : une concurrence plus accessible
Swift 6 apporte une base solide pour une gestion plus sûre de la concurrence dans les applications de l’écosystème Apple. Swift 6.2, livré avec Xcode 26 en même temps qu’iOS 26, accentue cette philosophie : rendre la concurrence correcte dès l’écriture du code, grâce aux erreurs de compilation plutôt qu’aux conventions et à la rigueur des développeurs. Deux nouveautés concernent directement le développement concurrent.
Le mode single-threaded par défaut (default isolation)
Il est désormais possible d’isoler tout le code d’un module sur le MainActor sans annotation explicite. En activant l’option default-isolation, Swift déclare automatiquement tous les types et fonctions du module sur le MainActor. C’est une façon de revenir à un développement où tout le code s’exécute sur le main thread, sauf si l’on décide explicitement d’en sortir.
Le nouvel attribut @concurrent
C’est précisément le rôle de la seconde nouveauté : l’attribut @concurrent. Il permet d’identifier clairement les fonctions qui doivent s’exécuter de manière concurrente, en dehors du MainActor. Le code gagne aussi en lisibilité : tout ce qui n’est pas marqué @concurrent reste sur le MainActor, le reste s’exécute en parallèle.
FAQ : les questions fréquentes sur la concurrence en Swift
C’est la vérification complète de la concurrence par le compilateur. En mode Swift 6, tout risque de data race détecté (par exemple la capture d’un type non-Sendable dans une Task détachée) provoque une erreur de compilation au lieu d’un warning.
La concurrence en Swift désigne la capacité d’exécuter plusieurs tâches en parallèle (requêtes réseau, traitements de données, mise à jour de l’interface) de façon sûre. Depuis Swift Concurrency, elle s’appuie sur async/await, les tasks et les actors plutôt que sur DispatchQueue et les completion handlers.
Swift Concurrency (async/await, actors, structured concurrency) est arrivé avec Swift 5.5 en 2021. Swift 6, en 2024, a rendu la vérification des data races obligatoire en mode Swift 6, et Swift 6.2 a simplifié son adoption.
Non. La migration peut se faire module par module. La démarche recommandée consiste à passer d’abord par Swift 5.10 avec strict-concurrency=complete, à corriger les warnings, puis à activer le mode Swift 6.
Et après ? Évolutions et documentation Swift Concurrency
On peut s’attendre à ce qu’Apple continue dans cette direction : sécuriser les applications en réduisant le nombre de bugs qui pourraient passer inaperçus dans des cas complexes, tout en rendant cette sécurité accessible au plus grand nombre de développeurs. Une philosophie cohérente avec l’ambition d’un catalogue d’applications misant sur la qualité. La documentation officielle de Swift Concurrency reste la référence pour approfondir chacun de ces concepts.
Vous avez aimé cet article ?
Abonnez-vous à notre newsletter pour ne rien rater de l’actualité Tech et Finance.


Pas encore de commentaires