Que vaut-il mieux utiliser : NSOperationQueue ou GCD ?

Le choix entre NSOperationQueue et GCD dépend des exigences spécifiques de la tâche.

GCD (Grand Central Dispatch) - API de bas niveau en C pour la programmation parallèle, basée sur le concept de files d’attente.

NSOperationQueue - API de haut niveau en Objective-C/Swift, construite sur GCD. Elle offre des fonctionnalités supplémentaires.

Principales différences:

Caractéristique	GCD	NSOperationQueue
Niveau d’API	Bas niveau	Haut niveau
Type de tâches	Blocs de code (closures en Swift)	Objets Operation
Dépendances	Pas de support natif	Supporte les dépendances entre opérations
Priorité	Supporte	Supporte, avec possibilité de changer
Annulation de tâches	Difficile à implémenter	Facile via cancel()
Surveillance	Non intégré	Propriétés pour la surveillance (isExecuting, isFinished)
Nombre maximum de tâches parallèles	Aucun contrôle direct	Peut définir maxConcurrentOperationCount
Héritage	Non applicable aux blocs	Peut hériter pour créer des opérations personnalisées

Quand utiliser GCD:

• Lorsque la performance maximale et le minimum de surcharge sont requis.
• Pour des tâches simples en arrière-plan, sans logique complexe ou dépendances.
• Lors de l’utilisation d’API de bas niveau.

Par exemple, pour exécuter une tâche courte CPU-bound en arrière-plan:

// DispatchQueue.global(qos: .userInitiated) - file d’attente globale avec priorité définie.
// async - exécution asynchrone du bloc de code.
DispatchQueue.global(qos: .userInitiated).async {
    // Exécuter une tâche gourmande en ressources
    let result = self.performExpensiveCalculation()

    // Passer à la file principale pour mettre à jour l’UI
    DispatchQueue.main.async {
        self.updateUI(with: result)
    }
}

Quand utiliser NSOperationQueue:

• Lorsque les tâches ont des dépendances et doivent s’exécuter dans un ordre précis.
• Lorsqu’il est nécessaire d’annuler facilement des tâches ou de surveiller leur statut.
• Pour contrôler le nombre maximal de tâches s’exécutant simultanément.
• Pour des tâches plus complexes ou de longue durée.
• Lorsqu’il faut créer des unités de travail réutilisables et encapsulées (Operation).

Exemple avec dépendance:

import Foundation

// Opération pour charger des données
let downloadOperation = BlockOperation {
    print("Chargement des données...")
    Thread.sleep(forTimeInterval: 2) // Simulation de retard
    print("Données chargées.")
}

// Opération pour traiter les données, dépendante du chargement
let processOperation = BlockOperation {
    print("Traitement des données...")
    Thread.sleep(forTimeInterval: 1) // Simulation de retard
    print("Données traitées.")
}

// Ajouter la dépendance : processOperation attend la fin de downloadOperation
processOperation.addDependency(downloadOperation)

// Créer une file d’opérations
let operationQueue = OperationQueue()

// Ajouter les opérations à la file
operationQueue.addOperation(downloadOperation)
operationQueue.addOperation(processOperation)

// Attendre que toutes les opérations soient terminées (pour la démo, normalement pas fait)
operationQueue.waitUntilAllOperationsAreFinished()
print("Toutes les opérations sont terminées.")

Résumé:

• Pour des tâches simples, indépendantes et avec une performance maximale, privilégier GCD.
• Pour des scénarios plus complexes avec dépendances, annulations et surveillance, NSOperationQueue est préférable.

NSOperationQueue ajoute une couche d’abstraction et de fonctionnalités sur GCD, le rendant plus pratique pour certaines tâches, mais avec un léger overhead. Dans la majorité des cas, NSOperationQueue est un bon choix si ses fonctionnalités supplémentaires sont nécessaires.