Planificateur de tâches Swift (iOS/macOS) : GCD…

Planificateur de tâches Swift (iOS/macOS) : GCD, OperationQueue et Timer

Dans le développement iOS et macOS, la gestion des tâches asynchrones, des exécutions différées et du multithreading est la base des performances et de la réactivité des applications. En Swift, trois composants clés sont utilisés pour cela : GCD (Grand Central Dispatch), OperationQueue et Timer. Dans cet article, nous allons détailler chacun d'eux, montrer des exemples de code et expliquer quand les utiliser.

1. Grand Central Dispatch (GCD) — DispatchQueue

GCD est une API C de bas niveau que Swift expose via DispatchQueue. Elle permet d'exécuter des tâches de manière asynchrone, parallèle ou séquentielle, en gérant automatiquement les threads.

Types de files d'attente principaux :

Main Queue — file d'attente séquentielle, exécute les tâches sur le thread principal (UI).
Global Queues — files d'attente parallèles avec différentes priorités (background, user-initiated, utility).
Custom Serial/Concurrent Queues — créées par le développeur.

Exemple : chargement asynchrone de données

import Foundation

// On obtient une file d'attente globale en arrière-planDispatchQueue.global(qos: .background).async {    // Travail lourd (analyse, téléchargement)    let data = try? Data(contentsOf: URL(string: "https://example.com/data.json")!)        // Retour sur le thread principal pour mettre à jour l'UI    DispatchQueue.main.async {        // Mise à jour de l'interface        print("Données chargées : \\(data?.count ?? 0) octets")    }}

Exécution différée (dispatch_after)

let deadline = DispatchTime.now() + 3.0 // dans 3 secondesDispatchQueue.main.asyncAfter(deadline: deadline) {    print("3 secondes se sont écoulées")}

Groupes de tâches (DispatchGroup)

let group = DispatchGroup()

group.enter()DispatchQueue.global().async {    // Tâche 1    Thread.sleep(forTimeInterval: 2)    group.leave()}

group.enter()DispatchQueue.global().async {    // Tâche 2    Thread.sleep(forTimeInterval: 1)    group.leave()}

// Notification de fin de toutes les tâchesgroup.notify(queue: .main) {    print("Toutes les tâches sont terminées")}

2. OperationQueue — planificateur de haut niveau

OperationQueue est construit au-dessus de GCD, mais offre plus de flexibilité : on peut définir des dépendances entre les opérations, des priorités, annuler des tâches individuelles, limiter le nombre maximum d'opérations parallèles.

Création et exécution d'opérations

let queue = OperationQueue()queue.maxConcurrentOperationCount = 2 // pas plus de 2 tâches parallèles

let operation1 = BlockOperation {    print("Opération 1")    Thread.sleep(forTimeInterval: 1)}

let operation2 = BlockOperation {    print("Opération 2")    Thread.sleep(forTimeInterval: 1)}

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

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

Annulation d'opérations

operation1.cancel() // Annule l'opération si elle n'est pas encore en cours d'exécution

// Vérification d'annulation à l'intérieur de l'opérationlet cancellableOp = BlockOperation {    if !cancellableOp.isCancelled {        print("En cours d'exécution")    }}

Caractéristiques clés d'OperationQueue :

On peut définir qualityOfService (priorité).
Les opérations peuvent être des objets Operation avec la méthode main() redéfinie.
Prend en charge KVO (Key-Value Observing) pour le suivi de l'état.