Care este diferența dintre mutex, semafor și lock?

lock în C# este un zahăr sintactic pentru utilizarea Monitor.Enter și Monitor.Exit, învelite într-un bloc try-finally pentru a garanta eliberarea blocajului. Oferă acces exclusiv la o resursă pentru un singur fir de execuție. În esență, este cel mai simplu primitiv de sincronizare la nivel de obiect.

Mutex este un primitiv de sincronizare care poate fi folosit pentru a oferi acces exclusiv la o resursă pentru un singur fir de execuție între mai multe procese. Are un concept de proprietate asupra firului: doar firul care a obținut mutex-ul îl poate elibera.

Semaphore este un primitiv de sincronizare care limitează numărul de fire de execuție care pot accesa o resursă simultan. Are un contor care scade la obținerea accesului și crește la eliberare.

Diferențele principale sunt prezentate în tabel:

Caracteristică	lock (Monitor)	Mutex	Semaphore
Domeniu de vizibilitate	În interiorul unui proces	Între procese	Între procese
Număr de fire de execuție	Doar unul	Doar unul (proprietar)	Număr limitat
Proprietate	Legat de firul de execuție	Legat de firul de execuție	Nu legat de firul de execuție
Utilizare	Sincronizare simplă	Sincronizare între procese, mutex-uri numite	Limitarea accesului paralel la o resursă
Excepții	Nu necesită gestionare explicită a AbandonedMutexException	Necesită gestionare a AbandonedMutexException	Nu există AbandonedSemaphoreException

// Exemplu de utilizare lock
private readonly object _lockObject = new object();

public void DoSomethingWithLock()
{
    lock (_lockObject)
    {
        // Secțiune critică
    }
}

// Exemplu de utilizare Mutex
using System.Threading;

private Mutex _mutex = new Mutex();

public void DoSomethingWithMutex()
{
    _mutex.WaitOne(); // Obține mutex-ul
    try
    {
        // Secțiune critică
    }
    finally
    {
        _mutex.ReleaseMutex(); // Eliberează mutex-ul
    }
}

// Exemplu de utilizare Semaphore
using System.Threading;

private Semaphore _semaphore = new Semaphore(3, 3); // Permite 3 fire de execuție simultan

public void DoSomethingWithSemaphore()
{
    _semaphore.WaitOne(); // Obține "acces" la semafor
    try
    {
        // Secțiune critică, limitată la 3 fire
    }
    finally
    {
        _semaphore.Release(); // Eliberează "acces"
    }
}