Blokowanie wyłączne (Exclusive Locking)#
Blokowanie wyłączne to mechanizm synchronizacji gwarantujący, że w danej chwili tylko jeden wątek ma dostęp do chronionego zasobu (sekcji krytycznej). Inne wątki próbujące uzyskać dostęp muszą czekać (są blokowane lub aktywnie czekają) do momentu zwolnienia blokady.
Instrukcja lock#
Słowo kluczowe lock to najprostszy i najczęściej stosowany sposób synchronizacji w C#. Jest to cukierek składniowy na klasę System.Threading.Monitor. Obiektem blokady może być dowolny typ referencyjny.
lock(lockObject)
{
statement(s);
}Instrukcja lock jest tłumaczona następująco:
object __lockObj = lockObject;
bool __lockWasTaken = false;
try
{
Monitor.Enter(__lockObj, ref __lockWasTaken);
statement(s);
}
finally
{
if (__lockWasTaken) Monitor.Exit(__lockObj);
}Jest to bardzo szybki mechanizm, jeśli nie dochodzi do rywalizacji. W przypadku rywalizacji wątek jest blokowany przez system operacyjny. Instrukcja lock działa tylko w obrębie jednego procesu. Ponadto, jak wspomniano we wstępie, przed i po bloku instrukcji lock wstawiana jest bariera pamięci.
int counter = 0, times = 1_000_000;
object locker = new object();
var increment = Task.Run(() =>
{
for (int i = 0; i < times; i++)
lock(locker) counter++;
});
var decrement = Task.Run(() =>
{
for (int i = 0; i < times; i++)
lock(locker) counter--;
});
await Task.WhenAll(increment, decrement);
Console.WriteLine($"Counter Value: {counter}");Kod źródłowy:
Od C# 13 i .NET 9 zaleca się używanie w instrukcji
lockobiektu typuSystem.Threading.Locklub bezpośrednie korzystanie z typuLock. Jeżeli obiektem blokady jest obiekt typuLock, to instrukcjalocktłumaczy się następująco:Lock.Scope scope = lockObject.EnterScope(); try { statement(s); } finally { scope.Dispose(); }Obiektu
Lockmożna używać też bezpośrednio:int counter = 0, times = 1_000_000; var locker = new Lock(); var increment = Task.Run(() => { for (int i = 0; i < times; i++) using(locker.EnterScope()) counter++; }); var decrement = Task.Run(() => { for (int i = 0; i < times; i++) using(locker.EnterScope()) counter--; }); await Task.WhenAll(increment, decrement); Console.WriteLine($"Counter Value: {counter}");
Kompilator używa
Lock.EnterScope()tylko wtedy, gdy statycznie wie, że wyrażenie jest typuLock. Jeżeli obiektLockzostanie przekonwertowany na inny typ (np.object), instrukcjalockwraca do klasyMonitor- kompilator sygnalizuje to ostrzeżeniem CS9216 w miejscu konwersji:Lock locker = new(); object o = locker; // warning CS9216 lock (o) { } // Monitor.Enter/Exit, not Lock.EnterScope()Ponadto
Locknie ma odpowiednikaMonitor.Wait/Monitor.Pulse(zob. Sygnalizacja), więc zmienna warunkowa nadal wymaga blokowania na zwykłym obiekcie. Podobnie jakMonitor,Lockpozwala na ponowne wejście tego samego wątku (reentrancy) i jest związany z wątkiem: musi zostać zwolniony przez wątek, który go zajął. Dlatego wewnątrz blokulocknie można używaćawait, a obiektuLock.Scope(będącegoref struct) nie można zachować pomiędzy wywołaniamiawait(błąd CS4007).
Mutex#
Klasa System.Threading.Mutex to prymityw synchronizacji działający na poziomie jądra systemu operacyjnego.
Może być nazwany, co pozwala na synchronizację wątków pomiędzy różnymi procesami (np. zapobieganie uruchomieniu drugiej instancji aplikacji). Jest znacznie wolniejszy od instrukcji lock (nawet bez rywalizacji zwykle kilkadziesiąt razy wolniejszy), ponieważ jest ciężkim obiektem poziomu jądra.
int counter = 0, times = 1_000_000;
using var mutex = new Mutex();
var increment = Task.Run(() =>
{
for (int i = 0; i < times; i++)
{
mutex.WaitOne();
try
{
counter++;
}
finally
{
mutex.ReleaseMutex();
}
}
});
var decrement = Task.Run(() =>
{
for (int i = 0; i < times; i++)
{
mutex.WaitOne();
try
{
counter--;
}
finally
{
mutex.ReleaseMutex();
}
}
});
await Task.WhenAll(increment, decrement);
Console.WriteLine($"Counter Value: {counter}");Kod źródłowy:
SpinLock#
System.Threading.SpinLock to lekka struktura, która realizuje blokowanie poprzez aktywne oczekiwanie (busy waiting). Zamiast blokować wątek (co kosztuje czas na przełączenie kontekstu), wątek aktywnie czeka, sprawdzając dostępność blokady.
SpinLock jest idealny dla bardzo krótkich sekcji krytycznych, gdzie czas oczekiwania jest krótszy niż czas przełączenia kontekstu wątku. Aktywne oczekiwanie zużywa 100% czasu procesora na danym rdzeniu podczas czekania.
Niewłaściwe użycie
SpinLock(np. w długich sekcjach krytycznych) może drastycznie obniżyć wydajność programu.
int counter = 0, times = 1_000_000;
SpinLock spinLock = new SpinLock();
var increment = Task.Run(() =>
{
for (int i = 0; i < times; i++)
{
bool lockTaken = false;
try
{
spinLock.Enter(ref lockTaken);
counter++;
}
finally
{
if (lockTaken) spinLock.Exit();
}
}
});
var decrement = Task.Run(() =>
{
for (int i = 0; i < times; i++)
{
bool lockTaken = false;
try
{
spinLock.Enter(ref lockTaken);
counter--;
}
finally
{
if (lockTaken) spinLock.Exit();
}
}
});
await Task.WhenAll(increment, decrement);
Console.WriteLine($"Counter Value: {counter}");Kod źródłowy: