Wie wird die Arbeit mit Threads und Tasks gehandhabt, wenn mehrere von ihnen auf einen gemeinsamen Zustand zugreifen?

Um sicherer Zugriff auf den gemeinsam genutzten Zustand in einer Multithread-Umgebung erfolgt durch Synchronisationsmechanismen.

Hauptansätze:

• Locks: lock ist der am weitesten verbreitete Mechanismus. Es gewährleistet exklusiven Zugriff auf einen Codeblock oder ein Objekt für einen Thread zur Zeit. Mutex (wechselseitiger Ausschluss) wird ebenfalls verwendet, aber häufig bei interprozessualer Kommunikation.
• Semantiken: Begrenzen die Anzahl der Threads, die gleichzeitig auf eine Ressource zugreifen können.
• Monitor: Repräsentiert eine mächtigere Version von lock, die es Threads erlaubt, auf Benachrichtigungen anderer Threads zu warten.
• ReadWriteLock: Ermöglicht mehreren Threads, Daten gleichzeitig zu lesen, aber nur einem Thread zu schreiben.
• Atomare Operationen: Für einfache Operationen (Inkrement, Dekrement, Vergleichs-Austausch) können statische Methoden der Klasse Interlocked verwendet werden.

Beim Arbeiten mit Tasks, insbesondere mit async/await, ist es wichtig zu beachten, dass Tasks nicht an einen bestimmten Thread gebunden sind. Synchronisationskontexte (SynchronizationContext) helfen, nach Abschluss einer asynchronen Operation zum gewünschten Kontext (z.B. UI-Thread) zurückzukehren.

Beispiel für die Verwendung von lock:

// Objekt zum Sperren
private readonly object _lockObject = new object();
private int _sharedCounter = 0;

public void IncrementCounter()
{
    // Sperrt den Zugriff auf den gemeinsamen Zähler
    lock (_lockObject)
    {
        _sharedCounter++;
    }
}

Beispiel für die Verwendung von Interlocked:

private int _sharedAtomicCounter = 0;

public void IncrementAtomicCounter()
{
    // Atomarer Inkrement
    Interlocked.Increment(ref _sharedAtomicCounter);
}