Planificateur de tâches Swift (iOS/macOS)

Planificateur de tâches Swift (iOS/macOS) : Guide complet

Le planificateur de tâches (Task Scheduler) est un composant clé du développement sous iOS et macOS, permettant de gérer efficacement les opérations asynchrones, les tâches en arrière-plan et le multithreading. Swift propose plusieurs outils puissants : Grand Central Dispatch (GCD), OperationQueue, le nouveau mécanisme async/await (Swift Concurrency) et le framework Combine. Dans cet article, nous analyserons en détail chacun d'eux, avec des exemples de code et des recommandations pour choisir l'outil approprié.

1. Grand Central Dispatch (GCD)

GCD est une bibliothèque de bas niveau pour la gestion des tâches parallèles. Elle fonctionne avec des files d'attente (DispatchQueue) et assure une répartition efficace des threads.

Types principaux de files d'attente :

main — file d'attente principale (thread UI).
global — files d'attente en arrière-plan avec différentes priorités (QoS).
private — files d'attente personnalisées (serial ou concurrent).

Exemple d'utilisation de GCD :

import Foundation

// Tâche asynchrone en arrière-planDispatchQueue.global(qos: .background).async {    let result = performHeavyComputation()        // Retour sur le thread principal pour mettre à jour l'UI    DispatchQueue.main.async {        updateUI(with: result)    }}

// File d'attente série pour une exécution séquentiellelet serialQueue = DispatchQueue(label: "com.example.serial")serialQueue.async {    // Tâche 1}serialQueue.async {    // Tâche 2 (s'exécute après la tâche 1)}

// File d'attente concurrentelet concurrentQueue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)concurrentQueue.sync {    // Opération bloquante (attention !)}

2. OperationQueue

OperationQueue est une abstraction de plus haut niveau au-dessus de GCD. Elle fonctionne avec des objets Operation, qui peuvent être configurés, annulés et liés par des dépendances.

Avantages d'OperationQueue :

Gestion flexible des dépendances entre les tâches.
Prise en charge intégrée de l'annulation et des priorités.
Observation KVO de l'état des opérations.

Exemple avec BlockOperation :

import Foundation

let operationQueue = OperationQueue()operationQueue.maxConcurrentOperationCount = 2

let operation1 = BlockOperation {    print("Tâche 1")}let operation2 = BlockOperation {    print("Tâche 2")}let operation3 = BlockOperation {    print("Tâche 3")}

// Définition d'une dépendance : la tâche 3 s'exécute après les tâches 1 et 2operation3.addDependency(operation1)operation3.addDependency(operation2)

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

// Annulation de toutes les opérationsoperationQueue.cancelAllOperations()

Création d'une sous-classe Operation personnalisée :

class DownloadOperation: Operation {    private let url: URL        init(url: URL) {        self.url = url    }        override func main() {        guard !isCancelled else { return }        // Exécution du téléchargement        let data = try? Data(contentsOf: url)        // Traitement du résultat    }}

let downloadOp = DownloadOperation(url: URL(string: "https://example.com/data")!)operationQueue.addOperation(downloadOp)

3. Swift Concurrency (async/await)

Depuis Swift 5.5, une prise en charge intégrée de la programmation asynchrone est disponible via les mots-clés async, await et Task. Il s'agit d'une méthode moderne et sécurisée pour travailler avec la concurrence.