C# / .NET Kompendium PLEN
.NET / C# / C# — fundamenty języka

lock, Mutex, Semaphore - synchronizacja w C

To nawiązuje wprost do tematu thread-safety, o którym mówiliśmy przy Singletonach - wszystkie trzy mechanizmy służą do kontrolowania dostępu wielu wątków do współdzielonego zasobu, ale różnią się zasięgiem, semantyką i kosztem.

lock - najprostszy, w ramach jednego procesu

lock to cukier składniowy nad Monitor.Enter/Monitor.Exit - zapewnia, że tylko jeden wątek naraz może wykonywać dany blok kodu.

public class CounterService
{
    private readonly object _lockObject = new object();
    private int _count = 0;

    public void Increment()
    {
        lock (_lockObject) // tylko JEDEN wątek na raz może wejść do tego bloku
        {
            _count++;
        }
    }
}

To dokładnie rozwiązanie, o którym wspominałem przy race condition z _count++ - lock gwarantuje, że cała operacja odczyt-dodaj-zapisz wykona się atomowo względem innych wątków próbujących wejść w ten sam lock.

Co dzieje się "pod spodem":

// lock (_lockObject) { _count++; } kompiluje się w przybliżeniu do:
bool lockTaken = false;
try
{
    Monitor.Enter(_lockObject, ref lockTaken);
    _count++;
}
finally
{
    if (lockTaken) Monitor.Exit(_lockObject);
}

Kluczowe ograniczenia lock: - Działa tylko w ramach jednego procesu (jednej aplikacji) - inny proces nie ma jak "zobaczyć" tego locka - Blokuje dokładnie jeden wątek na raz (jak Mutex z licznikiem 1, ale bez możliwości konfiguracji) - Nie da się użyć await wewnątrz lock - to jest częsta pułapka na rozmowie:

lock (_lockObject)
{
    await SomeAsyncMethod(); // ❌ Błąd kompilacji: "cannot await in the body of a lock statement"
}

To ograniczenie wynika z tego, że lock musi być zwolniony na tym samym wątku, który go zajął - await może wznowić wykonanie na innym wątku (jak omawialiśmy przy SynchronizationContext), co złamałoby tę gwarancję.

Mutex - jak lock, ale między procesami

Mutex (Mutual Exclusion) to synchronizacja na poziomie systemu operacyjnego - może działać nie tylko między wątkami w jednym procesie, ale między różnymi procesami na tym samym komputerze.

// Named Mutex - widoczny dla WSZYSTKICH procesów w systemie pod tą nazwą
using var mutex = new Mutex(false, "Global\\MyApp_SingleInstanceMutex");

if (mutex.WaitOne(TimeSpan.Zero)) // próbuj przejąć mutex, nie czekaj długo
{
    try
    {
        // Tylko JEDNA instancja aplikacji w całym systemie wykona ten kod naraz
        RunApplication();
    }
    finally
    {
        mutex.ReleaseMutex(); // MUSISZ zwolnić ręcznie
    }
}
else
{
    Console.WriteLine("Aplikacja już działa!");
}

Klasyczne zastosowanie - wymuszenie jednej instancji aplikacji na komputerze (Named Mutex widoczny globalnie w systemie):

static void Main()
{
    using var mutex = new Mutex(true, "Global\\MyWpfApp", out bool isNewInstance);
    if (!isNewInstance)
    {
        MessageBox.Show("Aplikacja już jest uruchomiona!");
        return; // zamknij tę drugą instancję
    }
    // normalny start aplikacji WPF
}

Ważna różnica względem lock - kto może zwolnić:

mutex.ReleaseMutex(); // MUSI być wywołane przez TEN SAM wątek, który wywołał WaitOne()
// inaczej: SynchronizationLockException

Koszt: Mutex jest znacznie wolniejszy niż lock, bo wymaga przejścia przez jądro systemu operacyjnego (kernel-mode) nawet przy braku rywalizacji o zasób - lock/Monitor w braku rywalizacji działa całkowicie w user-mode, bez wołania systemu operacyjnego, stąd jest szybszy.

Semaphore/SemaphoreSlim - pozwala na WIELE równoczesnych wątków (nie tylko jeden)

To jest fundamentalna różnica koncepcyjna względem lock/Mutex - semafor nie ogranicza do jednego wątku, tylko do określonej liczby równoczesnych wątków.

// Maksymalnie 3 wątki mogą jednocześnie wykonywać kod chroniony semaforem
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(3, 3); // (początkowa liczba miejsc, maksymalna)

public async Task ProcessOrderAsync(Order order)
{
    await _semaphore.WaitAsync(); // czeka, aż zwolni się "miejsce"
    try
    {
        await CallExternalApiAsync(order); // np. limit 3 równoczesnych requestów do zewnętrznego API
    }
    finally
    {
        _semaphore.Release(); // zwalnia "miejsce" dla kolejnego wątku
    }
}

Klasyczne zastosowanie: ograniczanie liczby równoczesnych operacji (throttling) - np. gdy zewnętrzne API pozwala na maksymalnie N równoczesnych requestów:

private readonly SemaphoreSlim _apiThrottle = new SemaphoreSlim(5); // max 5 naraz

public async Task<List<OrderDto>> FetchAllOrdersAsync(List<int> orderIds)
{
    var tasks = orderIds.Select(async id =>
    {
        await _apiThrottle.WaitAsync();
        try
        {
            return await _httpClient.GetFromJsonAsync<OrderDto>($"api/orders/{id}");
        }
        finally
        {
            _apiThrottle.Release();
        }
    });

    return (await Task.WhenAll(tasks)).ToList();
}

Mimo że startujesz np. 100 requestów naraz (Task.WhenAll), semafor gwarantuje, że maksymalnie 5 z nich faktycznie wykonuje się równocześnie - reszta czeka w kolejce na WaitAsync().

SemaphoreSlim vs Semaphore - która wersja

var semaphoreSlim = new SemaphoreSlim(3);  // ✅ preferowany - lekki, tylko w ramach procesu, wspiera async
var semaphore = new Semaphore(3, 3, "Global\\MySemaphore"); // named, między procesami, ale WOLNIEJSZY

SemaphoreSlim (dodany w .NET 4) jest lżejszy i wspiera WaitAsync() (kluczowe - w przeciwieństwie do lock, semafor można bezpiecznie łączyć z await), ale działa tylko w ramach jednego procesu. Zwykły Semaphore może być named (między procesami, jak Mutex), ale jest znacznie wolniejszy.

To jest zresztą kluczowa praktyczna zaleta semafora nad lock w kodzie asynchronicznym:

// ❌ lock - NIE MOŻNA użyć await w środku
lock (_lockObject) { await SomeAsyncMethod(); } // błąd kompilacji

// ✅ SemaphoreSlim - MOŻNA używać await
await _semaphore.WaitAsync();
try { await SomeAsyncMethod(); } // OK!
finally { _semaphore.Release(); }

To jest zresztą częsty powód, dla którego w nowoczesnym, asynchronicznym kodzie .NET (Web API) używa się SemaphoreSlim(1, 1) zamiast lock, gdy chroniony kod musi zawierać await:

private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1); // odpowiednik "async lock"

public async Task UpdateCacheAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        var freshData = await _apiClient.GetDataAsync(); // await wewnątrz - niemożliwe z lock
        _cache = freshData;
    }
    finally
    {
        _semaphore.Release();
    }
}

Tabela porównawcza

lock Mutex Semaphore/SemaphoreSlim
Ile wątków naraz 1 1 N (konfigurowalne)
Zasięg Jeden proces Może być między procesami (named) SemaphoreSlim: jeden proces; Semaphore: może być named
Wsparcie dla await ❌ Nie ❌ Nie (WaitOne blokujący) ✅ Tak (WaitAsync w SemaphoreSlim)
Wydajność Najszybszy (user-mode) Wolniejszy (kernel-mode) SemaphoreSlim: szybki; Semaphore: wolniejszy
Kto może zwolnić Musi być ten sam wątek (przez lock/Monitor) Musi być ten sam wątek Może zwolnić INNY wątek niż ten, który czekał
Typowe zastosowanie Ochrona współdzielonego stanu w pamięci (jak _count w Singletonie) Jedna instancja aplikacji, synchronizacja między procesami Throttling/limit równoczesnych operacji (np. requestów HTTP)

Nawiązanie do wcześniejszej rozmowy o Singleton/thread-safety

Jeśli masz Singleton z mutowalnym stanem:

public class CacheService // zarejestrowany jako Singleton
{
    private readonly Dictionary<string, object> _cache = new(); // NIE thread-safe samo z siebie
    private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);

    public async Task<object> GetOrAddAsync(string key, Func<Task<object>> factory)
    {
        if (_cache.TryGetValue(key, out var cached)) return cached;

        await _lock.WaitAsync();
        try
        {
            if (_cache.TryGetValue(key, out cached)) return cached; // double-check po wejściu do sekcji krytycznej

            var value = await factory(); // await wewnątrz - dlatego SemaphoreSlim, nie lock
            _cache[key] = value;
            return value;
        }
        finally
        {
            _lock.Release();
        }
    }
}

To jest realny wzorzec ("double-checked locking" z asynchronicznym semaforem) - dokładnie ten typ kodu, który musisz napisać poprawnie, gdy Singleton ma mutowalny, współdzielony stan i wymaga operacji asynchronicznych przy jego modyfikacji.

Podsumowanie - kiedy który

lock - domyślny wybór dla prostej ochrony sekcji krytycznej bez await w środku, w ramach jednego procesu - najszybszy. Mutex - gdy potrzebujesz synchronizacji między procesami (np. jedna instancja aplikacji) - rzadziej używany w typowym kodzie aplikacyjnym. SemaphoreSlim - gdy potrzebujesz (a) ograniczyć liczbę równoczesnych operacji do więcej niż jednej (throttling), lub (b) chronić sekcję kodu, która zawiera await (wtedy nawet z limitem 1, jako "async-friendly lock").

Postaw mi kawę