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 lock obiektu typu System.Threading.Lock lub bezpośrednie korzystanie z typu Lock. Jeżeli obiektem blokady jest obiekt typu Lock, to instrukcja lock tłumaczy się następująco:

Lock.Scope scope = lockObject.EnterScope();
try
{
    statement(s);
}
finally { scope.Dispose(); }

Obiektu Lock moż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 typu Lock. Jeżeli obiekt Lock zostanie przekonwertowany na inny typ (np. object), instrukcja lock wraca do klasy Monitor - 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 Lock nie ma odpowiednika Monitor.Wait/Monitor.Pulse (zob. Sygnalizacja), więc zmienna warunkowa nadal wymaga blokowania na zwykłym obiekcie. Podobnie jak Monitor, Lock pozwala 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 bloku lock nie można używać await, a obiektu Lock.Scope (będącego ref struct) nie można zachować pomiędzy wywołaniami await (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: