Thread d'arrière-plan en Swift : guide pour débutants et experts

Pourquoi les threads d'arrière-plan sont-ils la douleur de chaque développeur iOS ?

Imaginez : vous écrivez une application pour télécharger des photos depuis Internet. Tout fonctionne parfaitement... jusqu'à ce que l'utilisateur appuie sur le bouton "Télécharger". L'écran se fige, l'application ralentit, et après quelques secondes, iOS tue tout simplement votre processus. Cela vous dit quelque chose ?

Le problème est que toutes les opérations sont exécutées par défaut sur le thread principal (main thread). Or, le thread principal est responsable du rendu de l'interface utilisateur (UI) — si vous le bloquez avec une tâche longue, l'interface cessera de répondre aux touches. La solution ? Utiliser un thread d'arrière-plan (background thread) en Swift.

Dans cet article, nous allons voir comment travailler avec les threads d'arrière-plan sur des exemples concrets. Vous découvrirez GCD, OperationQueue et le nouvel async/await de Swift 5.5+. C'est parti !

Qu'est-ce qu'un thread en Swift ?

Un thread est un processus léger qui exécute le code d'un programme. Une application iOS possède un thread principal (main thread) et de nombreux threads d'arrière-plan. Le thread principal s'occupe de l'UI : il met à jour l'écran, gère les gestes, les animations. Tout ce qui concerne l'interface doit se produire uniquement sur le thread principal.

Les threads d'arrière-plan (background threads) sont nécessaires pour :

\n
• Télécharger des données depuis le réseau
\n
• Travailler avec des fichiers (lecture/écriture)
\n
• Effectuer des calculs complexes (traitement d'images, chiffrement)
\n
• Travailler avec des bases de données
\n

Si vous essayez de mettre à jour l'UI depuis un thread d'arrière-plan — l'application plantera avec une erreur, ou vous verrez un comportement étrange de l'interface.

GCD (Grand Central Dispatch) — la méthode classique

Grand Central Dispatch (GCD) est une bibliothèque de bas niveau pour la gestion des threads, intégrée à iOS/macOS. Elle fonctionne via des files d'attente (queues) : vous placez une tâche dans une file d'attente, et le système décide lui-même sur quel thread l'exécuter.

DispatchQueue.main — le thread principal

Si vous devez exécuter du code sur le thread principal (par exemple, mettre à jour un UILabel), utilisez :

DispatchQueue.main.async {\n    self.label.text = "Téléchargement terminé !"\n}

DispatchQueue.global() — le thread d'arrière-plan

Pour les tâches d'arrière-plan, utilisez la file d'attente globale :

DispatchQueue.global(qos: .background).async {\n    // Travail lourd\n    let imageData = try? Data(contentsOf: url)\n    \n    // Retour au thread principal pour l'UI\n    DispatchQueue.main.async {\n        self.imageView.image = UIImage(data: imageData!)\n    }\n}

Le paramètre qos (Quality of Service) détermine la priorité de la tâche :

\n
• .userInteractive — le plus élevé, pour l'UI
\n
• .userInitiated — l'utilisateur attend le résultat
\n
• .utility — tâches longues (téléchargement de fichiers)
\n
• .background — faible priorité (synchronisation, sauvegardes)
\n

OperationQueue — plus de contrôle

OperationQueue est une surcouche de GCD avec des fonctionnalités supplémentaires :

\n
• Annulation de tâches
\n
• Dépendances entre tâches
\n
• Nombre maximal de threads parallèles
\n

Exemple de téléchargement de plusieurs images :

let queue = OperationQueue()\nqueue.maxConcurrentOperationCount = 2 // Pas plus de 2 tâches simultanées\n\nlet operation1 = BlockOperation {\n    // Téléchargement de la première image\n    sleep(2)\n    print("Photo 1 téléchargée")\n}\n\nlet operation2 = BlockOperation {\n    // Téléchargement de la deuxième image\n    sleep(3)\n    print("Photo 2 téléchargée")\n}\n\n// operation2 ne commencera qu'après la fin de operation1\noperation2.addDependency(operation1)\n\nqueue.addOperations([operation1, operation2], waitUntilFinished: false)

C'est pratique lorsque vous devez exécuter des tâches dans un ordre strict ou avec une limitation des ressources.

async/await moderne (Swift 5.5+)

Depuis Swift 5.5, Ap