Files d'attente de tâches en Swift : GCD, OperationQueue et Combine pour iOS/macOS

Files d'attente de tâches pour Swift (iOS/macOS) : Guide complet

Dans le développement iOS et macOS, une gestion efficace des threads et des files d'attente de tâches est la clé pour créer des applications réactives et performantes. Swift propose plusieurs outils puissants pour travailler avec l'asynchronisme : du classique Grand Central Dispatch (GCD) au modèle moderne async/await et au framework Combine. Dans cet article, nous allons analyser les approches principales, leurs particularités et des exemples d'utilisation.

1. Grand Central Dispatch (GCD) — le fondement du multithreading

GCD est une bibliothèque bas niveau d'Apple pour gérer l'exécution parallèle du code. L'élément principal est DispatchQueue, qui peut être séquentielle (serial) ou parallèle (concurrent).

Files d'attente principales :

• main — la file d'attente principale (thread UI). Toutes les mises à jour de l'interface doivent y être exécutées.
• global — les files d'attente parallèles système avec différentes priorités (background, utility, default, userInitiated, userInteractive).
• custom — les files d'attente personnalisées, créées via DispatchQueue(label:attributes:).

Exemple : chargement d'une image en arrière-plan

import UIKit

class ImageLoader {    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {        DispatchQueue.global(qos: .background).async {            guard let data = try? Data(contentsOf: url),                  let image = UIImage(data: data) else {                DispatchQueue.main.async {                    completion(nil)                }                return            }            DispatchQueue.main.async {                completion(image)            }        }    }}

2. OperationQueue — gestion flexible des tâches

OperationQueue est une abstraction de plus haut niveau au-dessus de GCD. Elle permet de créer des dépendances entre les opérations, de définir le nombre maximum de tâches parallèles et d'annuler des opérations.

Fonctionnalités clés :

• Création de BlockOperation ou de sous-classes personnalisées de Operation.
• Définition de dépendances : operation2.addDependency(operation1).
• Annulation de toutes les opérations : queue.cancelAllOperations().
• Contrôle de la qualité de service (quality of service).

Exemple : chargement séquentiel de fichiers

import Foundation

let queue = OperationQueue()queue.maxConcurrentOperationCount = 1 // exécution séquentielle

let fetchMetadata = BlockOperation {    print("Chargement des métadonnées...")    Thread.sleep(forTimeInterval: 1)}

let downloadContent = BlockOperation {    print("Chargement du contenu...")    Thread.sleep(forTimeInterval: 2)}

downloadContent.addDependency(fetchMetadata)

queue.addOperations([fetchMetadata, downloadContent], waitUntilFinished: false)print("Opérations mises en file d'attente")

3. Swift Concurrency (async/await) — l'approche moderne

Depuis Swift 5.5, Apple a introduit un modèle d'asynchronisme intégré avec les mots-clés async et await. Il permet d'écrire du code asynchrone de manière linéaire, sans closures ni callbacks.

Composants principaux :

• async — marquage d'une fonction asynchrone.
• await — attente du résultat d'une opération asynchrone.
• Task — création d'un contexte asynchrone.
• TaskGroup — regroupement de tâches parallèles.

Exemple : chargement parallèle de données

import Foundation

func fetchUser(id: Int) async -> String {    // Simulation d'une requête réseau    try? await Task.sleep(nanoseconds: 1_000_000_000)    return "User_\\(id)"}

func loadAllUsers() async {    await withTaskGroup(of: String