Sur quoi se basent les barrières et les sémaphores?

Les barrières et sémaphores dans le contexte de la programmation parallèle reposent sur des mécanismes de synchronisation:

• Sémaphores: S'appuient sur des opérations atomiques sur un compteur. Opérations principales:

  • wait (ou P, acquérir): Décrémente le compteur. Si le compteur devient négatif, le thread est bloqué jusqu'à ce qu'un autre thread effectue un signal.
  • signal (ou V, libérer): Incrémente le compteur. Si des threads sont bloqués, l'un d'eux se réveille.
  • Les sémaphores peuvent être binaires (valeur 0 ou 1, agissent comme des mutex) ou comptables (permettent à un nombre limité de threads d'accéder à une ressource).

• Barrières: Se basent sur un mécanisme d'attente par tous les participants. Un thread atteignant la barrière se bloque jusqu'à ce que tous les autres threads impliqués dans la synchronisation atteignent également cette barrière. Une fois que tous atteignent la barrière, ils continuent simultanément.

Dans le développement iOS/macOS, ces concepts sont implémentés à l'aide de frameworks de programmation concurrente, tels que GCD (Grand Central Dispatch) et OperationQueue.

Par exemple, en GCD:

// Exemple d'utilisation de DispatchSemaphore
let semaphore = DispatchSemaphore(value: 1) // Sémaphore binaire

// Wait (acquérir)
semaphore.wait()
// Accès à la section critique
semaphore.signal() // Signal (libérer)

Les barrières en GCD sont implémentées à l'aide de tâches barrières (barrier tasks) pour les files d'attente concurrentes:

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)

// Tâches normales
concurrentQueue.async {
    // ...
}

// Tâche barrière - s'exécute uniquement lorsque toutes les tâches normales précédentes sont terminées
// Et après cela, aucune nouvelle tâche ne commencera jusqu'à ce qu'elle se termine
concurrentQueue.async(flags: .barrier) {
    // ...
}

// Tâches normales qui commenceront après la fin de la tâche barrière
concurrentQueue.async {
    // ...
}