Quelle est la différence entre mutex, sémaphore et…

lock en C# est un sucre syntaxique pour utiliser Monitor.Enter et Monitor.Exit, enveloppés dans un bloc try-finally pour garantir la libération du verrou. Il fournit un accès exclusif à une ressource pour un seul thread. En substance, c'est le primitive de synchronisation le plus simple au niveau de l'objet.

Mutex est une primitive de synchronisation qui peut être utilisée pour fournir un accès exclusif à une ressource pour un seul thread de plusieurs processus. Il a une notion de propriété du thread : seul le thread qui a obtenu le mutex peut le libérer.

Semaphore est une primitive de synchronisation qui limite le nombre de threads pouvant accéder à une ressource simultanément. Il possède un compteur qui diminue lors de l'obtention de l'accès et augmente lors de sa libération.

Les principales différences sont présentées dans le tableau :

Caractéristique	`lock` (Monitor)	`Mutex`	`Semaphore`
Portée de visibilité	Au sein d'un seul processus	Entre processus	Entre processus
Nombre de threads	Un seul	Un seul (propriétaire)	Nombre limité
Propriété	Lié au thread	Lié au thread	Non lié au thread
Utilisation	Synchronisation simple	Synchronisation entre processus, mutex nommés	Limitation de l'accès parallèle à une ressource
Exceptions	Ne nécessite pas de gestion explicite d'AbandonedMutexException	Nécessite la gestion d'AbandonedMutexException	Pas d'AbandonedSemaphoreException

// Exemple d'utilisation de lock
private readonly object _lockObject = new object();

public void DoSomethingWithLock()
{
    lock (_lockObject)
    {
        // Section critique
    }
}

// Exemple d'utilisation de Mutex
using System.Threading;

private Mutex _mutex = new Mutex();

public void DoSomethingWithMutex()
{
    _mutex.WaitOne(); // Obtenir le mutex
    try
    {
        // Section critique
    }
    finally
    {
        _mutex.ReleaseMutex(); // Libérer le mutex
    }
}

// Exemple d'utilisation de Semaphore
using System.Threading;

private Semaphore _semaphore = new Semaphore(3, 3); // Permet 3 threads simultanément

public void DoSomethingWithSemaphore()
{
    _semaphore.WaitOne(); // Obtenir "l'accès" au sémaphore
    try
    {
        // Section critique, accès limité à 3 threads
    }
    finally
    {
        _semaphore.Release(); // Libérer "l'accès"
    }
}

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