Hoe verschillen mutex en semafoor van lock?

lock in C# is syntactic sugar voor het gebruik van Monitor.Enter en Monitor.Exit, ingepakt in een try-finally-blok om de lock gegarandeerd vrij te geven. Het biedt exclusieve toegang tot een resource voor één thread. In wezen is het de eenvoudigste synchronisatie-primitief op objectniveau.

Mutex is een synchronisatie-primitief die gebruikt kan worden om exclusieve toegang tot een resource te bieden voor één thread over meerdere processen. Het heeft een concept van thread-eigendom: alleen de thread die de mutex heeft verkregen, kan deze vrijgeven.

Semaphore is een synchronisatie-primitief die het aantal threads beperkt dat gelijktijdig toegang kan krijgen tot een resource. Het heeft een teller die afneemt bij het verkrijgen van toegang en toeneemt bij het vrijgeven.

De belangrijkste verschillen worden weergegeven in de tabel:

Kenmerk	lock (Monitor)	Mutex	Semaphore
Zichtbaarheidsscope	Binnen één proces	Tussen processen	Tussen processen
Aantal threads	Alleen één	Alleen één (eigenaar)	Beperkt aantal
Eigendom	Thread-gebonden	Thread-gebonden	Niet thread-gebonden
Gebruik	Eenvoudige synchronisatie	Synchronisatie tussen processen, genummerde mutexen	Beperking van gelijktijdige toegang tot een resource
Uitzonderingen	Vereist geen expliciete handling van AbandonedMutexException	Vereist handling van AbandonedMutexException	Geen AbandonedSemaphoreException

// Voorbeeld van gebruik van lock
private readonly object _lockObject = new object();

public void DoSomethingWithLock()
{
    lock (_lockObject)
    {
        // Kritieke sectie
    }
}

// Voorbeeld van gebruik van Mutex
using System.Threading;

private Mutex _mutex = new Mutex();

public void DoSomethingWithMutex()
{
    _mutex.WaitOne(); // Mutex verkrijgen
    try
    {
        // Kritieke sectie
    }
    finally
    {
        _mutex.ReleaseMutex(); // Mutex vrijmaken
    }
}

// Voorbeeld van gebruik van Semaphore
using System.Threading;

private Semaphore _semaphore = new Semaphore(3, 3); // Staat 3 threads tegelijk toe

public void DoSomethingWithSemaphore()
{
    _semaphore.WaitOne(); // "Toegang" tot semaphore verkrijgen
    try
    {
        // Kritieke sectie, beperkt tot 3 threads
    }
    finally
    {
        _semaphore.Release(); // "Toegang" vrijmaken
    }
}