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 bezawaitw ś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 zawieraawait(wtedy nawet z limitem 1, jako "async-friendly lock").