Quelle est la différence entre un sémaphore et un mutex?

Un sémaphore est un mécanisme de synchronisation généralisé utilisé pour gérer l'accès à une ressource limitée par plusieurs threads concurrents. Il maintient une valeur entière qui diminue lors de la prise de la ressource et augmente lors de sa libération. Si la valeur du sémaphore est zéro, la tentative de l'acquérir bloque le thread jusqu'à ce qu'un autre thread libère la ressource. Il peut être utilisé pour limiter le nombre de threads fonctionnant simultanément.

Un mutex (exclusion mutuelle) est un sémaphore binaire qui peut être dans un état bloqué ou débloqué. Il est utilisé pour protéger les sections critiques du code contre l'accès simultané par plusieurs threads. Un seul thread peut acquérir le mutex à un moment donné. Le thread qui a acquis le mutex ne peut pas être interrompu par un autre thread tentant de l'acquérir. Si l'on tente d'acquérir un mutex bloqué, le thread sera bloqué jusqu'à sa libération.

Différences clés :

Caractéristique	Sémaphore	Mutex
Type	Mécanisme de synchronisation généralisé	Sémaphore binaire (cas particulier du sémaphore)
Valeur	Entier (>= 0)	Binaire (0 ou 1)
But	Contrôle d'accès aux ressources, limitation des threads	Protection des sections critiques, exclusion mutuelle
Propriétaire	Peut ne pas avoir de propriétaire	A toujours un propriétaire (le thread qui l'a acquis)
Utilisation en iOS	DispatchSemaphore	Souvent implémenté via DispatchQueue.sync ou NSRecursiveLock dans certains scénarios

Exemple d'utilisation d'un mutex pour protéger une section critique :

// Dans le contexte de GCD (Grand Central Dispatch)
let serialQueue = DispatchQueue(label: "com.example.criticalSection")

serialQueue.sync {
    // Section critique du code
    // Un seul thread peut être ici à tout moment
}

Exemple d'utilisation d'un sémaphore pour limiter les tâches parallèles :

// Dans le contexte de GCD (Grand Central Dispatch)
let semaphore = DispatchSemaphore(value: 3) // Permet 3 tâches en parallèle

DispatchQueue.global().async {
    semaphore.wait() // Diminue la valeur du sémaphore de 1. Bloque si la valeur est 0.

    // Code de la tâche en parallèle
    print("Tâche en cours")

    Thread.sleep(forTimeInterval: 1) // Simulation de travail

    semaphore.signal() // Augmente la valeur du sémaphore de 1. Débloque le thread en attente, s'il y en a.
    print("Tâche terminée")
}

// Plusieurs de ces blocs peuvent être lancés. Seuls 3 s'exécuteront simultanément.