Worin unterscheiden sich Mutex und Semaphore von…

lock in C# ist ein syntaktischer Zucker für die Verwendung von Monitor.Enter und Monitor.Exit, eingewickelt in einen try-finally-Block, um die Freigabe der Sperre zu garantieren. Es bietet exklusiven Zugriff auf eine Ressource für einen einzelnen Thread. Im Wesentlichen ist es das einfachste Synchronisationsprimitive auf Objektebene.

Mutex ist ein Synchronisationsprimitive, das verwendet werden kann, um exklusiven Zugriff auf eine Ressource für einen einzelnen Thread über mehrere Prozesse hinweg zu gewährleisten. Es hat ein Konzept des Thread-Besitzes: Nur der Thread, der den Mutex erhalten hat, kann ihn freigeben.

Semaphore ist ein Synchronisationsprimitive, das die Anzahl der Threads begrenzt, die gleichzeitig auf eine Ressource zugreifen können. Es hat einen Zähler, der beim Zugriff verringert und bei Freigabe erhöht wird.

Die wichtigsten Unterschiede sind in der Tabelle dargestellt:

Charakteristik	`lock` (Monitor)	`Mutex`	`Semaphore`
Sichtbarkeitsbereich	Innerhalb eines Prozesses	Zwischen Prozessen	Zwischen Prozessen
Anzahl der Threads	Nur einer	Nur einer (Besitzer)	Begrenzte Anzahl
Besitz	Thread-gebunden	Thread-gebunden	Nicht thread-gebunden
Verwendung	Einfache Synchronisation	Synchronisation zwischen Prozessen, benannte Mutexes	Begrenzung des parallelen Zugriffs auf eine Ressource
Ausnahmen	Erfordert keine explizite Behandlung von AbandonedMutexException	Erfordert Behandlung von AbandonedMutexException	Keine AbandonedSemaphoreException

// Beispiel für die Verwendung von lock
private readonly object _lockObject = new object();

public void DoSomethingWithLock()
{
    lock (_lockObject)
    {
        // Kritischer Abschnitt
    }
}

// Beispiel für die Verwendung von Mutex
using System.Threading;

private Mutex _mutex = new Mutex();

public void DoSomethingWithMutex()
{
    _mutex.WaitOne(); // Mutex erhalten
    try
    {
        // Kritischer Abschnitt
    }
    finally
    {
        _mutex.ReleaseMutex(); // Mutex freigeben
    }
}

// Beispiel für die Verwendung von Semaphore
using System.Threading;

private Semaphore _semaphore = new Semaphore(3, 3); // Erlaubt 3 Threads gleichzeitig

public void DoSomethingWithSemaphore()
{
    _semaphore.WaitOne(); // "Zugriff" auf Semaphore erhalten
    try
    {
        // Kritischer Abschnitt, Zugriff auf 3 Threads beschränkt
    }
    finally
    {
        _semaphore.Release(); // "Zugriff" freigeben
    }
}

Worin unterscheiden sich Mutex und Semaphore von Lock?