Wstęp#

Współbieżny dostęp do zasobów wymaga stosowania mechanizmów synchronizacji, aby uniknąć wyścigów (race conditions) i zapewnić spójność danych. Platforma .NET udostępnia zestaw prymitywów synchronizacji, które różnią się przeznaczeniem, zasięgiem (wewnątrzprocesowe lub międzyprocesowe) oraz kosztem wydajnościowym.

Dostępne mechanizmy można podzielić na cztery główne kategorie:

  • Blokowanie wyłączne (Exclusive locking) - gwarantuje, że tylko jeden wątek ma dostęp do zasobu w danym momencie.
    • instrukcja lock (Monitor lub, od C# 13/.NET 9, System.Threading.Lock)
    • Mutex
    • SpinLock
  • Blokowanie współdzielone (Non-exclusive locking) - ogranicza równoległość
    • Semaphore(Slim)
    • ReaderWriterLock(Slim)
  • Sygnalizacja (Signaling) - pozwala na komunikację między wątkami i oczekiwanie na określone zdarzenie.
    • ManualResetEvent(Slim), AutoResetEvent, CountdownEvent
    • Monitor.Wait, Monitor.Pulse (zmienne warunkowe)
    • Barrier
  • Inne niskopoziomowe - nie wymagają blokowania wątków.
    • MemoryBarrier
    • Interlocked

Problem#

W poniższym przykładzie zmienna complete nie jest zabezpieczona. Kompilator JIT (szczególnie w trybie Release) może zoptymalizować pętlę while w taki sposób, że wartość complete zostanie pobrana do rejestru procesora tylko raz. Mimo że główny wątek zmienia wartość na true, wątek poboczny może tego nigdy nie zauważyć, powodując zawieszenie programu.

class Program
{
    private static void Main()
    {
        bool complete = false;
        var thread = new Thread (() =>
        {
            bool toggle = false;
            while (!complete) 
            {
                toggle = !toggle;
            }
        });
        thread.Start();
        Thread.Sleep(1000);
        complete = true;
        thread.Join();
    }
}

Kod źródłowy:

Bariera pamięci (Memory Barrier/Fence)#

Bariera pamięci to instrukcja procesora lub kompilatora, która wymusza określony porządek wykonywania operacji na pamięci (odczytów i zapisów). Jest ona ważna z dwóch powodów:

  1. Zapobiega zmianie kolejności instrukcji:
    Zarówno kompilatory, jak i nowoczesne procesory optymalizują kod, zmieniając kolejność wykonywania instrukcji, jeśli uznają, że nie wpłynie to na wynik w ramach pojedynczego wątku. W środowisku wielowątkowym taka zmiana może jednak prowadzić do błędów, gdzie jeden wątek widzi zmiany w niewłaściwej kolejności. Bariera “powstrzymuje” te optymalizacje, gwarantując, że instrukcje przed barierą wykonają się przed instrukcjami za nią.
  2. Gwarantuje widoczność:
    W systemach wielordzeniowych zapis do zmiennej przez jeden wątek może najpierw trafić do bufora zapisu rdzenia (store buffer) lub zostać zatrzymany przez kompilator w rejestrze, przez co nie jest od razu widoczny dla innych rdzeni (i wątków). Bariera pamięci wymusza dokończenie takich oczekujących zapisów i zapobiega odczytywaniu nieaktualnych kopii, dzięki czemu inne wątki widzą najnowsze wartości. (Wbrew popularnemu przekonaniu bariera nie “zrzuca cache’u do RAM-u” - spójność pamięci podręcznych wszystkich rdzeni zapewnia sam sprzęt.)

W C# barierę można wywołać ręcznie, korzystając z metody Thread.MemoryBarrier. Rzadko jednak wywołuje się ją bezpośrednio, ponieważ bariery są generowane niejawnie przy:

  1. Instrukcji lock (przy wejściu i przy wyjściu)
  2. Metodach z prymitywów synchronizacji (np. Mutex, Semaphore, AutoResetEvent)
  3. Odczycie/zapisie pól volatile (półbariery: odczyt ma semantykę acquire, a zapis - release)
  4. Metodach z klasy Interlocked
  5. Uruchomieniu, czekaniu na wątek/Task

Klasa Interlocked#

Klasa Interlocked służy do wykonywania atomowych operacji na zmiennych współdzielonych przez wiele wątków. Jest to najszybszy i najlżejszy sposób synchronizacji prostych danych liczbowych lub referencji, bez konieczności używania cięższych prymitywów synchronizacji typu lock, Mutex.

Co to znaczy “atomowa operacja”? Operacja atomowa to taka, która jest niepodzielna. Z punktu widzenia innych wątków wykonuje się ona w całości albo wcale - nie można jej wykonać w połowie.

Na przykład atomowe nie są:

  • inkrementacja, dekrementacja
  • odczyt/zapis wartości 64-bitowych (long, double) na platformie 32-bitowej
  • swap

Przykład#

Operacje counter++ oraz counter-- nie są atomowe. Składają się z trzech etapów: odczytu, modyfikacji i zapisu. Gdy dwa zadania wykonują te operacje jednocześnie na tej samej zmiennej, dochodzi do nakładania się tych etapów. Wartość końcowa counter będzie nieprzewidywalna i niemal na pewno różna od zera.

int counter = 0, times = 1_000_000;

var increment = Task.Run(() =>
{
    for (int i = 0; i < times; i++)
        counter++;
});

var decrement = Task.Run(() =>
{
    for (int i = 0; i < times; i++)
        counter--;
});

await Task.WhenAll(increment, decrement);

Console.WriteLine($"Counter: {counter}");

Kod źródłowy:

Metody Interlocked.Increment i Interlocked.Decrement wymuszają na procesorze wykonanie całej operacji modyfikacji zmiennej jako jednej, niepodzielnej jednostki (używając sprzętowych instrukcji). Dodatkowo generują one pełną barierę pamięci, co gwarantuje poprawną widoczność zmian dla wszystkich rdzeni procesora. Kod jest bezpieczny wątkowo, a wartość końcowa counter zawsze będzie wynosić dokładnie 0.

int counter = 0, times = 1_000_000;

var increment = Task.Run(() =>
{
    for (int i = 0; i < times; i++)
        Interlocked.Increment(ref counter);
});

var decrement = Task.Run(() =>
{
    for (int i = 0; i < times; i++)
        Interlocked.Decrement(ref counter);
});

await Task.WhenAll(increment, decrement);

Console.WriteLine($"Counter: {counter}");