Travailler avec les files d'attente de tâches en Swift : GCD et OperationQueue

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi les files d'attente de tâches en Swift ?

Dans le développement moderne pour iOS et macOS, les performances de l'application dépendent directement de l'efficacité avec laquelle vous gérez les threads. Les opérations longues — chargement de données depuis le réseau, traitement d'images, travail avec une base de données — ne doivent pas bloquer le thread principal (Main Thread), responsable de l'interface. Si le thread principal est occupé, l'utilisateur voit un écran "gelé", et le système peut forcer la fermeture de l'application.

Les files d'attente de tâches (Task Queues) résolvent ce problème. Elles permettent d'exécuter du code de manière asynchrone, parallèle ou séquentielle, sans bloquer l'interface utilisateur. En Swift, il existe trois outils principaux pour cela : Grand Central Dispatch (GCD), OperationQueue et le modèle moderne async/await (Swift Concurrency). Dans cet article, nous allons les analyser avec des exemples pratiques et déterminer quand utiliser quoi.

1. Grand Central Dispatch (GCD) : l'approche classique

GCD est une bibliothèque bas niveau en C qui gère un pool de threads. En Swift, on l'utilise facilement via les files d'attente globales (DispatchQueue).

1.1. Types principaux de files d'attente dans GCD

Main Queue — file d'attente séquentielle du thread principal. Utilisée pour mettre à jour l'interface utilisateur.
Global Queues — files d'attente parallèles avec différentes priorités (QoS : .userInteractive, .userInitiated, .utility, .background).
Custom Queues — files d'attente créées par vous (peuvent être séquentielles ou parallèles).

1.2. Exemple : chargement de données en arrière-plan et mise à jour de l'interface utilisateur

Supposons que nous devions charger un JSON depuis un serveur distant et afficher le résultat dans un tableau.

DispatchQueue.global(qos: .userInitiated).async {
    // 1. Travail en arrière-plan : chargement des données
    guard let url = URL(string: "https://api.example.com/data") else { return }
    let data = try? Data(contentsOf: url)
    
    // 2. Retour sur le thread principal pour mettre à jour l'interface utilisateur
    DispatchQueue.main.async {
        // Mise à jour du modèle de données ou du tableau
        self.tableView.reloadData()
    }
}

1.3. Utilisation de DispatchGroup pour la synchronisation

Lorsque vous devez exécuter plusieurs tâches parallèles et attendre leur achèvement, utilisez DispatchGroup.

let group = DispatchGroup()
var images: [UIImage] = []

for url in imageURLs {
    group.enter()
    DispatchQueue.global().async {
        if let data = try? Data(contentsOf: url), let image = UIImage(data: data) {
            images.append(image)
        }
        group.leave()
    }
}

group.notify(queue: .main) {
    print("Toutes les images sont chargées : \\(images.count)")
    // Mise à jour de l'interface utilisateur
}

2. OperationQueue : un niveau d'abstraction plus élevé

OperationQueue est construite au-dessus de GCD, mais offre des fonctionnalités supplémentaires : annulation de tâches, dépendances entre opérations, contrôle du nombre maximum d'opérations parallèles.

2.1. Création et lancement d'opérations

Les opérations peuvent être créées via BlockOperation ou en héritant de Operation.

let queue = OperationQueue()
queue.maxConcurrentOperationCount = 2 // Limite à 2 tâches parallèles

let operation1 = BlockOperation {
    print("Opération 1 commencée")
    sleep(2)
    print("Opération 1 terminée")
}

let operation2 = BlockOperation {
    print("Opération 2 commencée")
    sleep(1)
    print("Opération 2 terminée")
}

// Définit une dépendance : operation2 ne commencera qu'après operation1
operation2.addDependency(operation1)

queue.addOperations([operation1, operation2], waitUntilFinished: false)