Miben különbözik a mutex és a semaphore a lock-tól…

A lock C#-ban szintaktikus cukor a Monitor.Enter és Monitor.Exit használatához, try-finally blokkba csomagolva, hogy garantálja a zárolás feloldását. Exkluzív hozzáférést biztosít egy erőforráshoz egyetlen szál számára. Lényegében ez az objektumszintű szinkronizáció legegyszerűbb primitívje.

A Mutex egy szinkronizációs primitív, amelyet arra lehet használni, hogy kizárólagos hozzáférést biztosítson egy erőforráshoz egyetlen szál számára több folyamat között. Van egy fogalmi tulajdonjog a szálakra vonatkozóan: csak az a szál, amelyik megszerezte a mutexet, tudja azt felszabadítani.

A Semaphore egy szinkronizációs primitív, amely korlátozza, hogy hány szál férhet hozzá egy erőforráshoz egyidejűleg. Van egy számlálója, amely csökken a hozzáférés megszerzésekor és növekszik a felszabadításkor.

A fő különbségek a táblázatban vannak bemutatva:

Jellemző	`lock` (Monitor)	`Mutex`	`Semaphore`
Láthatósági kör	Egy folyamaton belül	Folyamatok között	Folyamatok között
Szálak száma	Csak egyet	Csak egyet (tulajdonos)	Korlátozott számú
Tulajdonjog	Szálhoz kötött	Szálhoz kötött	Szálhoz nem kötött
Használat	Egyszerű szinkronizáció	Folyamatok közötti szinkronizáció, névvel ellátott mutexek	Párhuzamos hozzáférés korlátozása egy erőforráshoz
Kivételek	Nem igényel explicit kezelését az AbandonedMutexException-nak	Igényli az AbandonedMutexException kezelését	Nincs AbandonedSemaphoreException

// Lock használat példája
private readonly object _lockObject = new object();

public void DoSomethingWithLock()
{
    lock (_lockObject)
    {
        // Kritikus szakasz
    }
}

// Mutex használat példája
using System.Threading;

private Mutex _mutex = new Mutex();

public void DoSomethingWithMutex()
{
    _mutex.WaitOne(); // Mutex megszerzése
    try
    {
        // Kritikus szakasz
    }
    finally
    {
        _mutex.ReleaseMutex(); // Mutex felszabadítása
    }
}

// Semaphore használat példája
using System.Threading;

private Semaphore _semaphore = new Semaphore(3, 3); // 3 szálat enged meg egyszerre

public void DoSomethingWithSemaphore()
{
    _semaphore.WaitOne(); // "Hozzáférés" a semaphore-hoz
    try
    {
        // Kritikus szakasz, 3 szálra korlátozva
    }
    finally
    {
        _semaphore.Release(); // "Hozzáférés" felszabadítása
    }
}

Miben különbözik a mutex és a semaphore a lock-tól?