Files d'attente de tâches en Swift : GCD, OperationQueue et Swift Concurrency

Files d'attente de tâches pour Swift (iOS/macOS) : GCD, OperationQueue et Swift Concurrency

Le développement sous iOS et macOS nécessite une gestion efficace des tâches parallèles. Les files d'attente de tâches (Task Queues) constituent un mécanisme fondamental pour créer des applications réactives et performantes. En Swift, il existe trois approches principales : le classique Grand Central Dispatch (GCD), l'orienté objet OperationQueue et le moderne async/await (Swift Concurrency). Dans cet article, nous analyserons en détail chacune d'elles avec des exemples pratiques.

1. Grand Central Dispatch (GCD) — DispatchQueue

GCD est une bibliothèque de bas niveau en langage C, intégrée au noyau du système. En Swift, elle est représentée par la classe DispatchQueue. Elle permet d'exécuter des blocs de code de manière séquentielle ou concurrente.

Types principaux de files d'attente :

• Main Queue — file d'attente séquentielle fonctionnant sur le thread principal. Utilisée pour la mise à jour de l'interface utilisateur.
• Global Queues — files d'attente concurrentes avec différentes priorités (QoS : userInteractive, userInitiated, utility, background).
• Custom Queues — files d'attente personnalisées (séquentielles ou concurrentes).

Exemple : Chargement asynchrone de données avec mise à jour de l'interface

import UIKit

class ViewController: UIViewController {    @IBOutlet weak var imageView: UIImageView!

    func loadImage(from url: URL) {        // Passage à une file d'attente d'arrière-plan        DispatchQueue.global(qos: .userInitiated).async { [weak self] in            guard let data = try? Data(contentsOf: url),                  let image = UIImage(data: data) else { return }

            // Retour au thread principal pour la mise à jour de l'interface            DispatchQueue.main.async {                self?.imageView.image = image            }        }    }}

Travail avec les sémaphores et les groupes

let group = DispatchGroup()let queue = DispatchQueue.global()

group.enter()queue.async {    print("Tâche 1 terminée")    group.leave()}

group.enter()queue.async {    print("Tâche 2 terminée")    group.leave()}

group.notify(queue: .main) {    print("Toutes les tâches sont terminées")}

2. OperationQueue et Operation

OperationQueue est une surcouche de GCD, offrant une interface orientée objet. Chaque tâche est une instance de la classe Operation (ou de sa sous-classe BlockOperation). Principaux avantages : gestion des dépendances, annulation des tâches et configuration du nombre maximum d'opérations parallèles.

Exemple : Chargement avec dépendances

let queue = OperationQueue()queue.maxConcurrentOperationCount = 2

let fetchData = BlockOperation {    print("Chargement des données...")}

let processData = BlockOperation {    print("Traitement des données...")}

let updateUI = BlockOperation {    print("Mise à jour de l'interface")}

// Définition des dépendances : processData s'exécutera après fetchDataprocessData.addDependency(fetchData)updateUI.addDependency(processData)

queue.addOperations([fetchData, processData, updateUI], waitUntilFinished: false)

Priorités et annulation de tâches

let operation = BlockOperation {    if Task.isCancelled { return }    print("En cours d'exécution...")}operation.queuePriority = .veryHigh

// Annulation de l'opérationoperation.cancel()

3. Swift Concurrency (async/await)

Depuis Swift 5.5, Apple a introduit un modèle d'asynchronisme intégré. async/await permet d'écrire du code asynchrone de manière linéaire, sans fermetures. Composants principaux : Task, TaskGroup, actor.

Exemple : Chargement asynchrone d'une image

import UIKit

class ImageLoader {    func loadImage(from url: URL) async throws -> UIImage {        let