Qu'est-ce que GCD (Grand Central Dispatch) et comment…

GCD (Grand Central Dispatch) est une technologie de bas niveau pour la parallélisation d'Apple, basée sur C, mais avec des wrappers pratiques en Swift et Objective-C. Elle fournit un mécanisme pour gérer des files d'attente de tâches (work items) et leur exécution asynchrone ou synchrone sur les cœurs de processeur disponibles.

Concepts principaux de GCD :

Queues de dispatch (Dispatch Queues) : Files pour exécuter des tâches. Il en existe deux types :
- Queues sériales : Les tâches s'exécutent séquentiellement, une après l'autre. Elles évitent les conditions de course lors de l'accès à des ressources partagées.
- Queues concurrentes : Les tâches s'exécutent en parallèle (mais l'ordre de démarrage et de fin n'est pas garanti). Utilisées pour des tâches indépendantes pouvant s'exécuter simultanément.
- Queue principale : Une queue séquentielle spéciale liée au thread principal de l'application. Utilisée pour mettre à jour l'UI. Toutes les tâches liées à l'UI doivent s'y exécuter.
Work Items (Closures/Blocks) : Blocs de code représentant une tâche à exécuter.
Groupe de dispatch (Dispatch Group) : Permet de grouper des tâches et de recevoir une notification lorsqu'elles sont toutes terminées.
Sémaphores de dispatch (Dispatch Semaphores) : Primitive de synchronisation pour gérer l'accès à des ressources limitées.

Utilisation en développement iOS :

Exécuter des opérations lourdes en arrière-plan : Déplacer des tâches comme des requêtes réseau, traitement d'images, travail avec des bases de données, de la queue principale vers des queues en arrière-plan (par exemple, queues globales concurrentes) pour éviter de bloquer l'UI.

// Exécuter une tâche asynchrone dans une queue parallèle globale
DispatchQueue.global(qos: .userInitiated).async {
    // Opération lourde
    let result = performHeavyOperation()

    // Mettre à jour l'UI sur le thread principal
    DispatchQueue.main.sync {
        updateUI(with: result)
    }
}

Mettre à jour l'UI : Toujours effectuer les opérations de modification de l'interface utilisateur sur la queue principale.

// Mettre à jour l'UI sur le thread principal
DispatchQueue.main.async {
    self.label.text = "Mis à jour!"
}

Sérialiser l'accès aux données : Utiliser des queues sériales personnalisées pour un accès synchronisé aux ressources modifiables partagées.

// Exemple de queue sériale pour un accès synchronisé
let dataAccessQueue = DispatchQueue(label: "com.myapp.dataaccess")

func updateSharedData(newValue: Int) {
    dataAccessQueue.async {
        // Modifier en toute sécurité les données partagées
        sharedData = newValue
    }
}

Regrouper des tâches : Attendre la fin de plusieurs tâches asynchrones avant de continuer.

// Groupe de tâches
let group = DispatchGroup()

group.enter() // Début de la tâche 1
performAsyncOperation1 {
    print("Tâche 1 terminée")
    group.leave()
}

group.enter() // Début de la tâche 2
performAsyncOperation2 {
    print("Tâche 2 terminée")
    group.leave()
}

// Notification à la fin de toutes les tâches du groupe
group.notify(queue: .main) {
    print("Toutes les tâches terminées, mise à jour de l'UI")
    // Mise à jour de l'UI
}

Exécution différée : Exécuter du code après un délai.

// Exécution différée après 2 secondes
DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
    print("Démarré après 2 secondes")
}

GCD offre une approche de haut niveau et efficace pour gérer les threads par rapport aux threads traditionnels (par exemple, Thread), en déléguant la gestion du pool de threads au système et en permettant une utilisation efficace des processeurs multi-cœurs.

Qu'est-ce que GCD (Grand Central Dispatch) et comment est-il utilisé dans le développement iOS?