Skip to content

8. Ausführungs-Threads

Dieses Kapitel führt in die gleichzeitige Ausführung mehrerer Codeabschnitte innerhalb eines einzigen Programms ein: Threads (Ausführungs-Threads) und die Werkzeuge zu ihrer Synchronisierung. Im Jahr 2008 besaßen die meisten Rechner nur einen Prozessor, und Parallelität war weitgehend eine vom Betriebssystem aufrechterhaltene Illusion. Heute verfügt selbst der einfachste Laptop über mehrere Kerne: Mehrere Threads laufen tatsächlich gleichzeitig, wodurch die hier behandelten Synchronisierungsprobleme noch häufiger auftreten.

Die Beispiele sind Einzeldatei-Anwendungen ([dotnet run threads-01.cs]) im Ordner [08-threads]. Beachten Sie, dass die impliziten [using]-Direktiven dieser Anwendungen [System.Threading] und [System.Threading.Tasks] umfassen: Die Klassen [Thread], [Lock], [Mutex], [Monitor], [Interlocked], [Task] … können ohne die Direktive [using] verwendet werden.

Ein Wort der Vorsicht vorab: Die Ergebnisse eines Multithreading-Programms variieren von einer Ausführung zur nächsten. Die Reihenfolge, in der den Threads der Prozessor zugeteilt wird, hängt vom Betriebssystem, von der Anzahl der Prozessoren und von der Auslastung des Rechners ab. Die in diesem Kapitel gezeigten Ergebnisse wurden auf einem Linux-Rechner mit zwei Prozessoren erzielt, der mit anderen Programmen geteilt wurde. Wenn Sie die Beispiele ausführen, erhalten Sie ähnliche Ergebnisse, die aber nur selten identisch sein werden.

8.1. Die Klasse Thread

Wenn eine Anwendung gestartet wird, läuft sie in einem Ausführungsstrang, dem sogenannten Thread. Die .NET-Klasse, die einen Thread modelliert, ist die Klasse [System.Threading.Thread]. Ihre wichtigsten Konstruktoren, Eigenschaften und Methoden sind die folgenden:

Member
Aufgabe
[Thread(ThreadStart start)]
erzeugt einen Thread, der die Methode [start] ausführt. Der Delegat [ThreadStart] verweist auf eine Methode ohne Parameter und ohne Rückgabewert: [void M()]
[Thread(ParameterizedThreadStart start)]
wie oben, aber mit einer Methode, die einen Parameter vom Typ [object?] hat: [void M(object? obj)]
[static Thread CurrentThread]
der Thread, der den Code ausführt, der diese Eigenschaft angefordert hat
[string? Name]
der Name des Threads, nützlich zur Nachverfolgung
[int ManagedThreadId]
ein eindeutiger numerischer Bezeichner des Threads
[bool IsBackground]
gibt an, ob der Thread ein Hintergrund-Thread ist (siehe unten)
[bool IsAlive]
gibt an, ob der Thread gerade läuft
[void Start()], [void Start(object? obj)]
startet die Ausführung des Threads und übergibt ihm optional Informationen vom Typ [object]
[void Join()], [bool Join(TimeSpan timeout)]
Der Thread T1, der [T2.Join()], ausführt, wird blockiert, bis der Thread T2 beendet ist. Die zweite Form begrenzt die Wartezeit
[static void Sleep(int ms)]
Der Thread, der die Methode ausführt, wird für [ms] Millisekunden angehalten. Er gibt die CPU ab, die an einen anderen Thread geht

Der Kurs von 2008 behandelte auch die Methode [Abort], die einen Thread gewaltsam beendete. Sie existiert praktisch nicht mehr: Seit .NET Core löst sie die Ausnahme [PlatformNotSupportedException] aus. Das abrupte Anhalten eines Threads konnte die Daten, die er gerade bearbeitete, in einem inkonsistenten Zustand hinterlassen. Heute wird ein Thread kooperativ zum Anhalten aufgefordert, und zwar über ein Abbruchtoken ([CancellationToken]) , das der Thread regelmäßig prüft: Das sehen wir im nächsten Kapitel.

Hier ist eine erste Anwendung, die die Existenz eines Haupt-Threads zeigt – desjenigen, der die Anweisungen der obersten Ebene des Programms ausführt (das Äquivalent der Methode [Main]). Das Programm [threads-01.cs] lautet wie folgt:

// der Hauptthread eines Programms

// der Thread, der diesen Code ausführt
Thread main = Thread.CurrentThread;
// am Anfang hat er keinen Namen
Console.WriteLine($"Name of the current thread: [{main.Name}]");
// wir geben ihm einen
main.Name = "Main";
Console.WriteLine($"Name of the current thread: [{main.Name}]");
// einige Eigenschaften
Console.WriteLine($"Identifier (ManagedThreadId): {main.ManagedThreadId}");
Console.WriteLine($"Background thread (IsBackground): {main.IsBackground}");
Console.WriteLine($"Pool thread (IsThreadPoolThread): {main.IsThreadPoolThread}");
Console.WriteLine($"Priority (Priority): {main.Priority}");
Console.WriteLine($"State (ThreadState): {main.ThreadState}");
Console.WriteLine($"Number of processors: {Environment.ProcessorCount}");

// eine Anzeige pro Sekunde
for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"{main.Name}: {DateTime.Now:HH:mm:ss}");
    // der Thread wird für 1 Sekunde angehalten
    Thread.Sleep(1000);
}

Ergebnisse:

> dotnet run threads-01.cs
Name of the current thread: []
Name of the current thread: [Main]
Identifier (ManagedThreadId): 1
Background thread (IsBackground): False
Pool thread (IsThreadPoolThread): False
Priority (Priority): Normal
State (ThreadState): Running
Number of processors: 2
Main: 11:35:54
Main: 11:35:55
Main: 11:35:56
Main: 11:35:57
Main: 11:35:58

Anmerkungen:

  • Zeile 4: Es wird ein Verweis auf den Thread abgerufen, der das Programm ausführt;
  • Zeilen 5–9: Wir zeigen seinen Namen an, ändern ihn und zeigen ihn erneut an. Anfangs hat der Haupt-Thread keinen Namen (Zeile 2 der Ergebnisse);
  • Zeilen 11–15: einige Eigenschaften des Threads. Der Haupt-Thread hat die ID 1; er ist ein Vordergrund-Thread ([IsBackground] ist gleich [False]), der nicht zum Thread-Pool gehört (auf diese beiden Konzepte gehen wir später ein); er läuft gerade ([Running]);
  • Zeile 16: Der Rechner, auf dem das Beispiel ausgeführt wurde, hat 2 Prozessoren;
  • Zeilen 19–23: eine Schleife, die jede Sekunde eine Meldung ausgibt. [Thread.Sleep(1000)] hält den Haupt-Thread für eine Sekunde an. Der Kurs von 2008 verwendete hier eine Endlosschleife, die mit Strg-C beendet wurde; wir beschränken uns auf fünf Ausgaben. Beachten Sie das Format [HH:mm:ss] (Stunden von 0 bis 23): Der Kurs von 2008 verwendete [hh], das Stunden von 1 bis 12 anzeigt.

8.2. Ausführungs-Threads erzeugen

Es ist möglich, Anwendungen zu haben, in denen Codeabschnitte „gleichzeitig“ in verschiedenen Ausführungs-Threads laufen. Hat der Rechner weniger Prozessoren als ausführungsbereite Threads, teilen sich die Threads die Prozessoren: Jeder nutzt abwechselnd für kurze Zeit (einige Millisekunden) einen Prozessor. Auf einem Mehrprozessorrechner laufen mehrere Threads tatsächlich gleichzeitig. Die einem Thread zugeteilte Zeit hängt von verschiedenen Faktoren ab, unter anderem von seiner Priorität, die einen Standardwert hat, aber programmatisch festgelegt werden kann (Eigenschaft [Priority]). Ein Thread, der den Prozessor besitzt, kann ihn vorzeitig abgeben:

  • indem er auf ein Ereignis wartet (Beendigung eines anderen Threads mit [Join], Warten auf ein Signal);
  • indem er für eine festgelegte Dauer in den Ruhezustand wechselt ([Sleep]).

Ein Thread T wird zunächst mit einem der oben vorgestellten Konstruktoren erzeugt, zum Beispiel:

Thread t = new Thread(Display);

wobei [Display] eine Methode mit einer der beiden folgenden Signaturen ist:

void Display();
void Display(object? obj);

Das Erzeugen eines Threads startet ihn nicht:

  • Die Ausführung des Threads T wird durch [T.Start()] eingeleitet: Die an den Konstruktor von T übergebene Methode wird dann vom Thread T ausgeführt. Der Code, der die Anweisung [T.Start()] ausführt, wartet nicht darauf, dass der Thread T fertig wird; er geht sofort zur nächsten Anweisung über. Wir haben dann zwei parallel laufende Threads. Sie müssen oft miteinander kommunizieren, um den Fortschritt der gemeinsamen Arbeit zu verfolgen: Das ist das Problem der Synchronisierung von Threads;
  • Einmal gestartet, läuft der Thread T eigenständig. Er endet, wenn die von ihm ausgeführte Methode beendet ist;
  • man kann mit [T.Join()] auf das Ende seiner Ausführung warten. Dies ist eine blockierende Anweisung: Der Thread, der sie ausführt, wird blockiert, bis der Thread T seine Arbeit beendet hat. Das ist eine grundlegende Synchronisierungsmethode.

Das Programm [threads-02.cs] lautet wie folgt:

// Erzeugung von Ausführungsthreads

// wir benennen den Hauptthread
Thread.CurrentThread.Name = "Main";

// Erzeugung von 5 Threads
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    // Thread Nr. i führt die Methode Display aus
    tasks[i] = new Thread(Display);
    // wir geben ihm einen Namen
    tasks[i].Name = i.ToString();
    // wir starten seine Ausführung (nicht blockierende Operation)
    tasks[i].Start();
}

// Ende des Hauptthreads
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// die von den Threads ausgeführte Methode
static void Display()
{
    // der Thread, der die Methode ausführt
    Thread current = Thread.CurrentThread;
    Console.WriteLine($"Start of execution of the Display method in thread {current.Name} (id {current.ManagedThreadId}): {DateTime.Now:HH:mm:ss.fff}");
    // 1 s schlafen
    Thread.Sleep(1000);
    Console.WriteLine($"End of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Anmerkungen:

  • Zeile 4: Wir geben dem Haupt-Thread einen Namen;
  • Zeilen 7–15: 5 Threads werden erzeugt und gestartet. Ihre Verweise werden in einem Array gespeichert, damit man sie später wiederfinden kann. Jeder Thread führt die Methode [Display] in den Zeilen 22–29 aus;
  • Zeile 11: Der Name der Methode [Display] wird automatisch in einen Delegaten vom Typ [ThreadStart] umgewandelt (Delegaten wurden im vorigen Kapitel eingeführt);
  • Zeile 15: Der Thread Nr. i wird gestartet. Diese Operation ist nicht blockierend: Der Thread Nr. i läuft parallel zum Haupt-Thread, der ihn gestartet hat;
  • Zeile 19: Der Haupt-Thread erreicht das Ende des Programms;
  • Zeilen 22–29: Die Methode [Display] zeigt den Namen und die ID des Threads, der sie ausführt, sowie die Start- und die Endzeit (auf die Millisekunde genau) der Ausführung an;
  • Zeile 28: Jeder Thread, der die Methode [Display] ausführt, pausiert für 1 Sekunde. Der Prozessor wird dann an einen anderen Thread übergeben, der auf den Prozessor wartet. Nach Ablauf der 1-sekündigen Pause ist der pausierte Thread wieder für den Prozessor berechtigt. Er erhält ihn, wenn er an der Reihe ist.

Ergebnisse:

> dotnet run threads-02.cs
Start of execution of the Display method in thread 2 (id 6): 11:36:01.725
Start of execution of the Display method in thread 4 (id 8): 11:36:01.725
End of thread Main at 11:36:01.725
Start of execution of the Display method in thread 0 (id 4): 11:36:01.725
Start of execution of the Display method in thread 1 (id 5): 11:36:01.725
Start of execution of the Display method in thread 3 (id 7): 11:36:01.725
End of execution of the Display method in thread 1: 11:36:02.779
End of execution of the Display method in thread 0: 11:36:02.778
End of execution of the Display method in thread 4: 11:36:02.779
End of execution of the Display method in thread 2: 11:36:02.779
End of execution of the Display method in thread 3: 11:36:02.779

Diese Ergebnisse sind sehr aufschlussreich:

  • Zunächst sehen wir, dass das Starten eines Threads nicht blockiert. Der Haupt-Thread hat 5 Threads gestartet und das Ende des Programms erreicht (Zeile 4), obwohl drei der gestarteten Threads ihre erste Meldung noch nicht angezeigt hatten;
  • die Reihenfolge, in der die Threads ausgeführt werden, ist nicht vorhersehbar: In diesem Durchlauf haben die Threads 2 und 4 ihre Startmeldungen vor Thread 0 angezeigt. Das Betriebssystem hat hier 6 Threads und 2 Prozessoren; es teilt den Threads die Prozessoren nach seinen eigenen Regeln zu;
  • Wir stellen außerdem fest, dass die Reihenfolge der Ausgaben nicht immer der Reihenfolge der angezeigten Uhrzeiten entspricht: Die Zeit wird vor ihrer Anzeige berechnet, und in der Zwischenzeit kann ein anderer Thread auf die Konsole geschrieben haben. [Console.WriteLine] ist threadsicher: Zwei Zeilen, die von zwei Threads geschrieben werden, vermischen sich nicht, aber ihre Reihenfolge ist nicht garantiert;
  • jeder Thread pausiert mit [Sleep] für eine Sekunde und beendet dann die Ausführung der Methode [Display];
  • Schließlich hat sich das Programm nicht beendet, als der Haupt-Thread seine Arbeit abgeschlossen hatte: Der Prozess wartete, bis alle 5 Threads fertig waren. Das liegt daran, dass diese Threads Vordergrund-Threads sind: Ein .NET-Prozess endet, wenn alle seine Vordergrund-Threads beendet sind.

Umgekehrt kann ein Thread zum Hintergrund-Thread erklärt werden, indem man vor dem Start seine Eigenschaft [IsBackground] auf [true] setzt. Hintergrund-Threads hindern den Prozess nicht am Beenden: Wenn der letzte Vordergrund-Thread endet, werden sie angehalten. Das Programm [threads-03.cs] lautet wie folgt:

// Hintergrund-Threads

// wir benennen den Hauptthread
Thread.CurrentThread.Name = "Main";

// Erzeugung von 5 Hintergrund-Threads
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    tasks[i] = new Thread(Display)
    {
        Name = i.ToString(),
        // ein Hintergrund-Thread verhindert nicht, dass der Prozess endet
        IsBackground = true
    };
    tasks[i].Start();
}

// wir geben den Threads Zeit zu starten
Thread.Sleep(100);
// Ende des Hauptthreads, damit auch des Prozesses
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// die von den Threads ausgeführte Methode
static void Display()
{
    Thread current = Thread.CurrentThread;
    Console.WriteLine($"Start of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
    // 1 s schlafen
    Thread.Sleep(1000);
    Console.WriteLine($"End of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Anmerkungen:

  • Zeile 14: Die 5 Threads sind Hintergrund-Threads. Die Eigenschaften [Name] und [IsBackground] werden mit einem Objektinitialisierer gesetzt;
  • Zeile 20: Der Haupt-Thread wartet 100 ms, um den Threads Zeit zum Starten zu geben, und beendet sich dann.

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run threads-03.cs
Start of execution of the Display method in thread 4: 11:36:04.770
Start of execution of the Display method in thread 3: 11:36:04.764
Start of execution of the Display method in thread 1: 11:36:04.766
Start of execution of the Display method in thread 0: 11:36:04.764
Start of execution of the Display method in thread 2: 11:36:04.766
End of thread Main at 11:36:04.872

Alle 5 Threads haben mit der Ausführung begonnen, dann hat sich der Haupt-Thread beendet (Zeile 7). Die Hintergrund-Threads wurden daraufhin während ihrer einsekündigen Pause angehalten: Es wird keine Endmeldung angezeigt. Der Kurs von 2008 erzielte dasselbe Ergebnis, indem er [Main] mit [Environment.Exit(0)] beendete, einer Anweisung, die alle Threads der Anwendung anhält, nicht nur den Thread, der sie ausführt. Die Threads des Thread-Pools, auf den wir später eingehen, sind Hintergrund-Threads.

Wenn der Haupt-Thread auf das Ende der von ihm erzeugten Threads warten möchte, verwendet er die Methode [Join]. Das Programm [threads-04.cs] zeigt außerdem eine weitere Möglichkeit, den Code festzulegen, den ein Thread ausführen soll: ein Lambda.

// Warten auf das Ende eines Threads mit Join - mit einem Lambda erzeugte Threads

// wir benennen den Hauptthread
Thread.CurrentThread.Name = "Main";

// Erzeugung von 5 Threads
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    // lokale Kopie von i, vom Lambda erfasst
    int number = i;
    // der Thread führt das Lambda aus, das Display mit einem typisierten Parameter aufruft
    tasks[i] = new Thread(() => Display(number, 1000 + 100 * number)) { Name = i.ToString() };
    tasks[i].Start();
}

// wir warten auf das Ende aller Threads
foreach (Thread task in tasks)
{
    // der Hauptthread ist bis zum Ende des Threads [task] blockiert
    task.Join();
}
// Ende des Hauptthreads
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// die von den Threads ausgeführte Methode
static void Display(int number, int duration)
{
    Console.WriteLine($"Start of execution of task {number} in thread {Thread.CurrentThread.Name}: {DateTime.Now:HH:mm:ss.fff}");
    // [duration] Millisekunden schlafen
    Thread.Sleep(duration);
    Console.WriteLine($"End of execution of task {number} in thread {Thread.CurrentThread.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Anmerkungen:

  • Zeile 13: Der Thread führt das Lambda [() => Display(number, 1000 + 100 * number)] aus. Ein Lambda ohne Parameter und ohne Rückgabewert ist mit dem Delegaten [ThreadStart] kompatibel. Diese Syntax erlaubt es, eine Methode mit typisierten Parametern (hier zwei [int]) statt der vorgeschriebenen Signatur [void M(object? obj)] aufzurufen;
  • Zeile 11: Das Lambda verwendet eine Kopie der Schleifenvariablen [i]. Das ist unerlässlich: Ein Lambda erfasst die Variable, nicht ihren Wert. In einer [for]-Schleife ist die Variable [i] über alle Iterationen hinweg dieselbe; würde das Lambda [i] verwenden, könnte ein Thread, der spät startet, den Wert von [i] aus einer späteren Iteration lesen, ja sogar den Endwert 5. Die im Schleifenrumpf deklarierte Variable [number] ist dagegen für jede Iteration eine neue Variable (auch eine [foreach]-Schleifenvariable ist seit C# 5 für jede Iteration neu);
  • Zeilen 18–21: Der Haupt-Thread wartet auf jeden der Threads. Er wird zunächst blockiert, bis Thread 0 fertig ist, dann bis Thread 1 und so weiter. Wenn er die Schleife verlässt, sind die 5 von ihm gestarteten Threads beendet;
  • Zeile 31: Thread Nr. i pausiert 1.000 + 100 × i Millisekunden, sodass die Threads in einer bekannten Reihenfolge enden.

Ergebnisse:

> dotnet run threads-04.cs
Start of execution of task 1 in thread 1: 11:36:06.779
Start of execution of task 3 in thread 3: 11:36:06.779
Start of execution of task 0 in thread 0: 11:36:06.779
Start of execution of task 4 in thread 4: 11:36:06.779
Start of execution of task 2 in thread 2: 11:36:06.779
End of execution of task 0 in thread 0: 11:36:07.828
End of execution of task 1 in thread 1: 11:36:07.928
End of execution of task 2 in thread 2: 11:36:08.029
End of execution of task 3 in thread 3: 11:36:08.128
End of execution of task 4 in thread 4: 11:36:08.228
End of thread Main at 11:36:08.229

Die letzte Zeile zeigt, dass der Haupt-Thread nach den von ihm gestarteten Threads beendet wurde, und zwar in dem Moment, als der letzte von ihnen fertig war.

8.3. Der Nutzen von Threads

Nachdem wir die Existenz eines Standard-Threads – desjenigen, der das Hauptprogramm ausführt – hervorgehoben haben und nun wissen, wie man weitere erzeugt, wollen wir den Nutzen von Threads betrachten. Sie haben zwei Hauptverwendungen:

  • alle Prozessoren des Rechners für eine zeitaufwendige Berechnung zu nutzen: Die Arbeit wird in Teile zerlegt, die verschiedenen Threads zugewiesen werden. Das tun wir am Ende dieses Kapitels mit der Bibliothek [Parallel].
  • mehrere Aufgaben gleichzeitig auszuführen, insbesondere wenn einige davon vor allem im Warten bestehen (auf eine Netzwerkantwort, einen Lesezugriff auf die Festplatte oder eine Benutzereingabe). Das ist bei Client-Server-Anwendungen im Internet der Fall, die wir in einem späteren Kapitel behandeln.

In einer Client-Server-Anwendung im Internet beantwortet ein Server, der sich auf einem Rechner namens S1 befindet, Anfragen von Clients auf entfernten Rechnern C1, C2, ..., Cn:

Image

Wir nutzen jeden Tag Internetanwendungen, die diesem Muster folgen: Webdienste, E-Mail, Dateiübertragungen und so weiter. Im obigen Schema muss der Server S1 die Clients Ci gleichzeitig bedienen. Nehmen wir das Beispiel eines Dateiservers: Wir wissen, dass eine Übertragung manchmal mehrere Minuten dauern kann. Es kommt nicht infrage, dass ein einzelner Client den Server über einen so langen Zeitraum monopolisiert. Eine gängige Lösung besteht darin, dass der Server so viele Ausführungs-Threads erzeugt, wie es Clients gibt. Jeder Thread ist dann für die Bearbeitung eines bestimmten Clients zuständig:

Image

In der Praxis verwendet der Server einen Thread-Pool mit einer begrenzten Anzahl von Threads, wie weiter unten beschrieben. Moderne Server gehen noch einen Schritt weiter: Während ein Client auf eine Antwort aus dem Netzwerk wartet, wird für ihn kein Thread reserviert. Möglich macht dies die asynchrone Programmierung, die Gegenstand des nächsten Kapitels ist.

8.4. Informationsaustausch zwischen Threads

In den bisherigen Beispielen führten die Threads eine Methode ohne Parameter aus. Der Konstruktor [Thread(ParameterizedThreadStart)] akzeptiert eine Methode mit der Signatur [void M(object? obj)]. Damit lassen sich Informationen an den gestarteten Thread übergeben:

t.Start(obj1);

startet den Thread [t], der dann die ihm bei der Konstruktion zugeordnete Methode ausführt und ihr den aktuellen Parameter [obj1] übergibt. Das Programm [threads-05.cs] lautet wie folgt:

// Informationsaustausch zwischen Threads

// wir benennen den Hauptthread
Thread.CurrentThread.Name = "Main";

// Erzeugung von 5 Threads
var tasks = new Thread[5];
var data = new Data[5];
for (int i = 0; i < tasks.Length; i++)
{
    // Thread Nr. i führt die Methode Sleep(object?) aus
    tasks[i] = new Thread(Sleep) { Name = i.ToString() };
    // das mit dem Thread ausgetauschte Objekt: der startende Thread setzt Start und Duration
    data[i] = new Data { Start = DateTime.Now, Duration = i + 1 };
    // wir starten den Thread und übergeben ihm dieses Objekt
    tasks[i].Start(data[i]);
}

// wir warten nacheinander auf die Threads
for (int i = 0; i < tasks.Length; i++)
{
    // Warten auf das Ende von Thread Nr. i
    tasks[i].Join();
    // Thread Nr. i hat die Eigenschaft End seines Objekts gefüllt
    Data d = data[i];
    Console.WriteLine($"Thread {tasks[i].Name} finished: start {d.Start:HH:mm:ss}, scheduled duration {d.Duration} s, end {d.End:HH:mm:ss}, actual duration {(d.End - d.Start).TotalSeconds:F3} s");
}
// Ende des Hauptthreads
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss}");

// die von den Threads ausgeführte Methode: Signatur void (object?)
static void Sleep(object? state)
{
    // wir rufen den Parameter mit seinem tatsächlichen Typ ab
    if (state is not Data info)
    {
        return;
    }
    // Duration Sekunden schlafen
    Thread.Sleep(info.Duration * 1000);
    // der gestartete Thread gibt dem startenden Thread ein Ergebnis zurück
    info.End = DateTime.Now;
}

// die zwischen dem startenden und dem gestarteten Thread ausgetauschte Information
class Data
{
    // vom startenden Thread gesetzt
    public DateTime Start { get; init; }
    public int Duration { get; init; }
    // vom gestarteten Thread gesetzt
    public DateTime End { get; set; }
}

Anmerkungen:

  • Zeilen 46–52: Die an die Threads übergebene Information ist ein Objekt [Data]. Zwischen dem startenden und dem gestarteten Thread findet ein beidseitiger Informationsaustausch statt. [Start] und [Duration] sind [init]-Eigenschaften: Sie können nur beim Erzeugen des Objekts gesetzt werden:
    • [Start]: der Startzeitpunkt der Ausführung des Threads, vom startenden Thread festgelegt;
    • [Duration]: Dauer der Pause des gestarteten Threads in Sekunden, vom startenden Thread festgelegt;
    • [End]: Endzeitpunkt der Ausführung des Threads, vom gestarteten Thread festgelegt;
  • Zeile 12: Jeder Thread ist der Methode [Sleep] in den Zeilen 32–42 zugeordnet, deren Signatur [void Sleep(object? state)] dem Delegaten [ParameterizedThreadStart]entspricht;
  • Zeilen 14–16: Ein Objekt [Data] wird erzeugt, im Array [data] gespeichert und dann an die Methode [Start] übergeben, die den Thread startet;
  • Zeilen 20–26: Der Haupt-Thread wartet darauf, dass jeder der von ihm gestarteten Threads fertig wird, ruft dann das Objekt [data[i]] des Threads Nr. i ab und zeigt dessen Inhalt an;
  • Zeile 35: Der empfangene Parameter hat den Typ [object?]; der Musterfilter [state is not Data info] prüft seinen tatsächlichen Typ und speichert ihn in der typisierten Variablen [info]. Der Kurs von 2008 führte eine Typumwandlung nach [(Data)state] durch, die eine Ausnahme auslöst, wenn das Objekt nicht den erwarteten Typ hat;
  • Zeile 40: Die Eigenschaft [Duration] des Parameters legt die Dauer der Pause fest;
  • Zeile 42: Die Eigenschaft [End] des Parameters wird gesetzt.

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run threads-05.cs
Thread 0 finished: start 11:36:10, scheduled duration 1 s, end 11:36:11, actual duration 1.044 s
Thread 1 finished: start 11:36:10, scheduled duration 2 s, end 11:36:12, actual duration 2.000 s
Thread 2 finished: start 11:36:10, scheduled duration 3 s, end 11:36:13, actual duration 3.000 s
Thread 3 finished: start 11:36:10, scheduled duration 4 s, end 11:36:14, actual duration 4.000 s
Thread 4 finished: start 11:36:10, scheduled duration 5 s, end 11:36:15, actual duration 5.000 s
End of thread Main at 11:36:15

Dieses Beispiel zeigt, dass zwei Threads Informationen austauschen können:

  • Der aufrufende Thread kann die Ausführung des aufgerufenen Threads steuern, indem er ihm Informationen liefert;
  • der gestartete Thread kann dem startenden Thread Ergebnisse zurückgeben.

Damit der aufrufende Thread weiß, wann die erwarteten Ergebnisse vorliegen, muss er benachrichtigt werden, wenn der aufgerufene Thread beendet ist. Hier hat er mit der Methode [Join] auf das Ende des aufgerufenen Threads gewartet. [Join] stellt außerdem sicher, dass alle Schreibvorgänge des aufgerufenen Threads für den wartenden Thread sichtbar sind. Weitere Möglichkeiten der Synchronisierung sehen wir später.

Mit einem Lambda ist es nicht mehr nötig, den Typ [object] zu verwenden: Das Lambda erfasst direkt typisierte Variablen. Die Zeilen 12–16 könnten wie folgt geschrieben werden:

1
2
3
4
Data d = new() { Start = DateTime.Now, Duration = i + 1 };
data[i] = d;
tasks[i] = new Thread(() => Sleep(d)) { Name = i.ToString() };
tasks[i].Start();

mit einer Methode [static void Sleep(Data data)] , die den Typ ihres Parameters nicht mehr prüfen muss. Dies ist heute der gebräuchlichste Ansatz.

8.5. Gleichzeitiger Zugriff auf gemeinsame Ressourcen

8.5.1. Nicht synchronisierter gleichzeitiger Zugriff

Im vorigen Abschnitt wurden Informationen nur zwischen zwei Threads und zu ganz bestimmten Zeitpunkten ausgetauscht: Das war ein klassisches Beispiel für die Parameterübergabe. Es gibt andere Fälle, in denen Informationen von mehreren Threads gemeinsam genutzt werden, die sie womöglich gleichzeitig lesen oder ändern wollen. Hier stellt sich die Frage nach der Integrität dieser Informationen. Angenommen, die gemeinsame Information ist eine Struktur S, die verschiedene Informationen I1, I2, ..., In enthält:

  • Ein Thread T1 beginnt, die Struktur S zu aktualisieren: Er ändert das Feld I1 und wird unterbrochen, bevor er die vollständige Aktualisierung der Struktur S abgeschlossen hat;
  • ein Thread T2, der den Prozessor erhält, liest dann die Struktur S, um Entscheidungen zu treffen. Er liest eine Struktur in einem instabilen Zustand: Einige Felder sind aktuell, andere nicht.

Diese Situation nennt man gleichzeitigen Zugriff auf eine gemeinsame Ressource – hier die Struktur S. Sie ist oft schwer zu beherrschen. Betrachten wir das folgende Beispiel, um die möglichen Probleme zu veranschaulichen:

  • Eine Anwendung erzeugt n Threads, wobei n als Parameter übergeben wird;
  • die gemeinsame Ressource ist ein Zähler, der von jedem erzeugten Thread erhöht werden muss;
  • am Ende der Anwendung wird der Wert des Zählers angezeigt. Er muss also n entsprechen.

Das Programm [threads-06.cs] lautet wie folgt:

// nicht synchronisierter nebenläufiger Zugriff auf eine gemeinsame Ressource

// Prüfung des Arguments: die Anzahl der zu erzeugenden Threads
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-06.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// Erzeugung und Start der Threads
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// Warten auf das Ende der Threads
foreach (Thread thread in threads)
{
    thread.Join();
}
// Anzeige des Zählers
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// die gemeinsame Ressource
static class Counter
{
    // der Thread-Zähler, von allen Threads gemeinsam genutzt
    public static int Value { get; private set; }

    // die von jedem Thread ausgeführte Methode
    public static void Increment()
    {
        // Lesen des Zählers
        int value = Value;
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {Thread.CurrentThread.Name} read the counter value: {value}");
        // Warten: der Thread verliert den Prozessor
        Thread.Sleep(1000);
        // Inkrementieren des Zählers
        Value = value + 1;
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {Thread.CurrentThread.Name} wrote the counter value: {Value}");
    }
}

Anmerkungen:

  • Zeilen 4–8: Die Anzahl der Threads wird als Argument übergeben. Die Bedingung in Zeile 5 fasst alle Prüfungen zusammen: Ein Argument ist erforderlich; es ist eine ganze Zahl ([int.TryParse]); und sie liegt zwischen 1 und 100 (relationales Muster [nbThreads is < 1 or > nbMaxThreads]). Das Programm gibt bei einem Fehler den Exitcode 1 zurück, andernfalls 0 (Zeile 25);
  • Zeilen 28–43: Die gemeinsame Ressource ist die statische Eigenschaft [Counter.Value]. Der Zähler ist in einer statischen Klasse gekapselt, mit der Methode [Increment] , die jeder Thread ausführt. Eine Anweisung der obersten Ebene kann kein Feld deklarieren: Daher sind die von den Threads gemeinsam genutzten Daten statische Member einer Klasse;
  • Zeile 37: Der Zähler wird gelesen;
  • Zeile 40: Der Thread pausiert für 1 Sekunde. Er verliert dadurch die CPU;
  • Zeile 42: Der Zähler wird erhöht.

Die einsekündige Pause dient nur dazu, den Thread zu zwingen, zwischen dem Lesen und dem Schreiben des Zählers den Prozessor zu verlieren. In der Praxis gibt es keine Garantie, dass ein Thread zwischen diesen beiden Zeitpunkten nicht unterbrochen wird, und auf einem Mehrprozessorrechner können zwei Threads den Zähler sogar genau gleichzeitig lesen. Die einsekündige Pause macht dieses Risiko lediglich systematisch.

Um einer Einzeldatei-Anwendung Argumente zu übergeben, stellen Sie sie hinter [--]:

> dotnet run threads-06.cs -- 5
At 11:36:17.169, thread 3 read the counter value: 0
At 11:36:17.169, thread 4 read the counter value: 0
At 11:36:17.169, thread 2 read the counter value: 0
At 11:36:17.169, thread 0 read the counter value: 0
At 11:36:17.169, thread 1 read the counter value: 0
At 11:36:18.216, thread 3 wrote the counter value: 1
At 11:36:18.216, thread 4 wrote the counter value: 1
At 11:36:18.217, thread 2 wrote the counter value: 1
At 11:36:18.217, thread 1 wrote the counter value: 1
At 11:36:18.217, thread 0 wrote the counter value: 1
Number of threads generated: 1

Wenn man diese Ergebnisse betrachtet, wird klar, was geschieht:

  • Ein erster Thread liest den Zähler. Er findet 0. Er pausiert für 1 Sekunde und verliert damit die CPU;
  • ein zweiter Thread liest ebenfalls den Wert des Zählers. Er ist immer noch 0, da der vorherige Thread ihn noch nicht erhöht hat. Auch er pausiert für 1 Sekunde;
  • in weniger als einer Sekunde haben alle 5 Threads Zeit, den Wert 0 zu lesen;
  • wenn sie aufwachen, erhöhen sie den gelesenen Wert 0 und schreiben alle den Wert 1 in den Zähler, wie die letzte Zeile (Zeile 12) bestätigt.

Man könnte einwenden, das Beispiel sei künstlich. Entfernen wir also das [Sleep] und verwenden wir den Operator [++], der die Illusion einer einzelnen Anweisung vermittelt. Das Programm [threads-07.cs] lautet wie folgt:

// verlorene Aktualisierungen ohne Sleep: counter++ ist nicht atomar

// Parameter: Anzahl der Threads, Anzahl der Inkremente pro Thread
int nbThreads = args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4;
int nbIncrements = args.Length > 1 && int.TryParse(args[1], out int m) ? m : 50_000_000;

// wir wiederholen das Experiment dreimal
for (int attempt = 1; attempt <= 3; attempt++)
{
    Counter.Value = 0;
    // Erzeugung und Start der Threads
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++)
    {
        threads[i] = new Thread(() =>
        {
            for (int j = 0; j < nbIncrements; j++)
            {
                // lesen, inkrementieren, schreiben: drei Operationen
                Counter.Value++;
            }
        });
        threads[i].Start();
    }
    // Warten auf das Ende der Threads
    foreach (Thread thread in threads)
    {
        thread.Join();
    }
    // Ergebnis
    int expected = nbThreads * nbIncrements;
    Console.WriteLine($"Attempt {attempt}: expected value {expected:N0}, obtained value {Counter.Value:N0}, lost updates {expected - Counter.Value:N0}");
}

// die gemeinsame Ressource
static class Counter
{
    public static int Value;
}

Anmerkungen:

  • Zeilen 4–5: Die Anzahl der Threads (standardmäßig 4) und die Anzahl der Erhöhungen pro Thread (standardmäßig 50 Millionen) können als Argumente übergeben werden. Der Ausdruck [args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4] liefert das Argument, wenn es existiert und gültig ist; andernfalls liefert er den Standardwert. Das Trennzeichen [_] macht die Konstante [50_000_000] lesbar;
  • Zeile 20: Jeder Thread erhöht den gemeinsamen Zähler ohne jede Pause;
  • Zeile 38: Diesmal ist der Zähler ein Feld;
  • Zeile 32: Das Format [N0] zeigt eine ganze Zahl mit Tausendertrennzeichen an.

Ergebnisse:

1
2
3
4
> dotnet run threads-07.cs
Attempt 1: expected value 200,000,000, obtained value 120,818,197, lost updates 79,181,803
Attempt 2: expected value 200,000,000, obtained value 121,419,329, lost updates 78,580,671
Attempt 3: expected value 200,000,000, obtained value 114,583,348, lost updates 85,416,652

Zig Millionen Aktualisierungen gingen verloren, und die Zahl schwankt von Test zu Test. Die Operation [Counter.Value++] der obersten Ebene wird tatsächlich in mehrere elementare Prozessoranweisungen übersetzt: den Wert aus dem Speicher lesen, ihn in einem Register erhöhen und das Ergebnis in den Speicher schreiben. Wenn zwei Threads denselben Wert lesen, bevor einer von ihnen seinen eigenen geschrieben hat, geht eine Erhöhung verloren, genau wie im vorigen Beispiel. Man braucht viele Iterationen, um dies zu beobachten: Bei einer Million Erhöhungen pro Thread hat jeder Thread seine Arbeit oft schon beendet, bevor der nächste gestartet ist, und das Ergebnis ist korrekt. Das macht diese Fehler so gefährlich: Ein Programm kann monatelang laufen und dann genau an dem Tag versagen, an dem das System stärker ausgelastet ist.

Woher kommt das Problem? Ein Thread hat einen veralteten Wert gelesen, weil ein anderer Thread unterbrochen wurde – oder gleichzeitig auf einem anderen Prozessor arbeitete –, bevor er seine Aufgabe, den Zähler zu aktualisieren, abgeschlossen hatte. Das führt uns zu den Begriffen der kritischen Ressource und des kritischen Abschnitts in einem Programm:

  • eine kritische Ressource ist eine Ressource, die zu einem Zeitpunkt nur von einem einzigen Thread gehalten werden kann. Hier ist die kritische Ressource der Zähler;
  • ein kritischer Abschnitt eines Programms ist eine Folge von Anweisungen im Ausführungsablauf eines Threads, während der dieser auf eine kritische Ressource zugreift. Wir müssen sicherstellen, dass der Thread während dieses kritischen Abschnitts als Einziger Zugriff auf die Ressource hat.

Im Programm [threads-06.cs] ist der kritische Abschnitt der Code zwischen dem Lesen des Zählers und dem Schreiben seines neuen Werts:

1
2
3
4
5
6
// Lesen des Zählers
int value = Value;
// Warten: der Thread verliert den Prozessor
Thread.Sleep(1000);
// Inkrementieren des Zählers
Value = value + 1;

Um diesen Code auszuführen, muss garantiert sein, dass ein Thread als Einziger läuft. Er darf unterbrochen werden, aber während dieser Unterbrechung darf kein anderer Thread denselben Code ausführen können. Die Plattform .NET bietet verschiedene Werkzeuge, um den exklusiven Zugriff auf kritische Codeabschnitte sicherzustellen. Einige davon betrachten wir jetzt.

8.5.2. Die Klausel [lock] und der Typ [Lock]

Die Klausel [lock] begrenzt einen kritischen Abschnitt wie folgt:

1
2
3
4
lock (padlock)
{
    // kritischer Abschnitt
}

[padlock] ist ein Objekt, das für alle Threads sichtbar ist, die den kritischen Abschnitt ausführen. Die Klausel [lock] stellt sicher, dass nur ein Thread gleichzeitig den kritischen Abschnitt ausführt: Ein Thread, der auf ein von einem anderen Thread gehaltenes Lock trifft, wird blockiert, bis das Lock freigegeben wird.

Ab C# 13 und .NET 9 sollte das Synchronisierungsobjekt vorzugsweise eine Instanz des Typs [System.Threading.Lock] sein, der genau für diesen Zweck entworfen wurde. Das vorige Beispiel wird in [threads-08.cs] wie folgt umgeschrieben:

// durch die Klausel lock und den Typ System.Threading.Lock geschützter kritischer Abschnitt (C# 13 / .NET 9)

// Prüfung des Arguments: die Anzahl der zu erzeugenden Threads
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-08.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// Erzeugung und Start der Threads
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// Warten auf das Ende der Threads, in umgekehrter Reihenfolge ihrer Erzeugung
Thread.CurrentThread.Name = "Main";
for (int i = nbThreads - 1; i >= 0; i--)
{
    Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread Main waits for the end of thread {threads[i].Name}");
    threads[i].Join();
    Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread Main was notified of the end of thread {threads[i].Name}");
}
// Anzeige des Zählers
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// die gemeinsame Ressource
static class Counter
{
    // der Thread-Zähler
    public static int Value { get; private set; }
    // das Synchronisationsobjekt, für alle Threads sichtbar
    private static readonly Lock padlock = new();

    // die von jedem Thread ausgeführte Methode
    public static void Increment()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} waits for permission to enter the critical section");
        // nur ein Thread gleichzeitig führt den folgenden Block aus
        lock (padlock)
        {
            // Lesen des Zählers
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // Warten: der Thread verliert den Prozessor, behält aber das Lock
            Thread.Sleep(1000);
            // Inkrementieren des Zählers
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} left the critical section");
    }
}

Anmerkungen:

  • Zeile 36: [padlock] ist das Objekt, das die Synchronisierung aller Threads ermöglicht. Es ist [readonly]: Die Referenz darf sich nie ändern, sonst könnten zwei Threads zwei verschiedene Objekte sperren;
  • Zeilen 44–53: Der kritische Abschnitt der Methode [Increment] ist von der Klausel [lock] umschlossen. Der Thread hält das Lock, während er eine Sekunde lang pausiert: Die anderen Threads können nicht eintreten;
  • Zeilen 20–24: Der Haupt-Thread wartet auf die Threads in umgekehrter Reihenfolge ihrer Erzeugung.

Ergebnisse mit 3 Threads:

> dotnet run threads-08.cs -- 3
At 11:36:23.809, thread Main waits for the end of thread 2
At 11:36:23.809, thread 0 waits for permission to enter the critical section
At 11:36:23.809, thread 1 waits for permission to enter the critical section
At 11:36:23.809, thread 2 waits for permission to enter the critical section
At 11:36:23.855, thread 0 read the counter value: 0
At 11:36:24.855, thread 0 wrote the counter value: 1
At 11:36:24.856, thread 1 read the counter value: 1
At 11:36:24.856, thread 0 left the critical section
At 11:36:25.856, thread 1 wrote the counter value: 2
At 11:36:25.856, thread 1 left the critical section
At 11:36:25.856, thread 2 read the counter value: 2
At 11:36:26.856, thread 2 wrote the counter value: 3
At 11:36:26.856, thread 2 left the critical section
At 11:36:26.857, thread Main was notified of the end of thread 2
At 11:36:26.857, thread Main waits for the end of thread 1
At 11:36:26.857, thread Main was notified of the end of thread 1
At 11:36:26.857, thread Main waits for the end of thread 0
At 11:36:26.857, thread Main was notified of the end of thread 0
Number of threads generated: 3
  • Alle drei Threads fordern nahezu gleichzeitig den Eintritt in den kritischen Abschnitt an;
  • nur einer tritt ein – hier Thread 0 (die Reihenfolge des Eintritts ist nicht garantiert: Nicht unbedingt der zuerst Eingetroffene tritt als Erster ein). Er liest den Zähler, pausiert eine Sekunde, schreibt den neuen Wert und verlässt den kritischen Abschnitt;
  • die beiden anderen Threads sind blockiert, bis der erste den kritischen Abschnitt verlässt, und gehen dann nacheinander hindurch. Jeder liest den vom vorherigen geschriebenen Wert;
  • der Haupt-Thread wartete auf das Ende von Thread 2. Wenn er benachrichtigt wird, wartet er auf das Ende von Thread 1, der bereits beendet ist: Er wird sofort benachrichtigt. Dasselbe gilt für Thread 0;
  • die Anzahl der Threads ist korrekt (Zeile 20).

Der Compiler übersetzt die Klausel [lock (padlock) { ... }] für ein [Lock]-Objekt wie folgt:

1
2
3
4
using (padlock.EnterScope())
{
    // kritischer Abschnitt
}

[EnterScope] erwirbt das Lock und gibt eine Struktur zurück, deren Methode [Dispose] – beim Verlassen des [using]-Blocks aufgerufen – das Lock freigibt, auch wenn der kritische Abschnitt eine Ausnahme auslöst. Der Typ [Lock] bietet außerdem die Methoden [Enter], [TryEnter], und [Exit] für Fälle, in denen das Lock nicht über einen Block verwaltet werden kann.

Vor .NET 9 und in viel vorhandenem Code war das Lock ein generisches Objekt, typischerweise vom Typ [object]:

1
2
3
4
5
6
private static readonly object synchro = new();
...
lock (synchro)
{
    // kritischer Abschnitt
}

Diese Form bleibt gültig: Jedes .NET-Objekt kann als Lock dienen. Der Compiler übersetzt sie dann in Aufrufe der Klasse [Monitor], die wir später untersuchen:

bool lockTaken = false;
try
{
    Monitor.Enter(synchro, ref lockTaken);
    // kritischer Abschnitt
}
finally
{
    if (lockTaken) Monitor.Exit(synchro);
}

Der Typ [Lock] ist effizienter und macht die Absicht explizit. Wir sperren immer ein privates Objekt: Würde man ein von außen sichtbares Objekt sperren ([this], einen Typ mit [typeof(...)], eine Zeichenfolge), könnte externer Code dasselbe Lock erwerben und unseres blockieren.

8.5.3. Die Klasse Mutex

Auch die Klasse [System.Threading.Mutex] erlaubt es, kritische Abschnitte zu begrenzen. Sie unterscheidet sich von der Klausel [lock] in der Sichtbarkeit:

  • Die Klausel [lock] synchronisiert Threads innerhalb derselben Anwendung;
  • die Klasse [Mutex] kann Threads verschiedener Anwendungen (oder Prozesse) synchronisieren, wenn ihr ein Name gegeben wird.

Ein [Mutex] ist ein Objekt des Betriebssystems: Seine Verwendung ist deutlich ressourcenintensiver als die eines [lock]. Für Threads desselben Prozesses verwenden wir daher bevorzugt [lock]; [Mutex] dient vor allem zwischen Prozessen. Wir verwenden die folgenden Konstruktoren und Methoden:

Member
Aufgabe
[Mutex()]
erzeugt einen anonymen Mutex M, der von den Threads des Prozesses verwendet werden kann
[Mutex(bool initiallyOwned, string name)]
erzeugt oder öffnet den benannten Mutex [name], der von allen Prozessen gemeinsam genutzt wird, die diesen Namen verwenden
[bool WaitOne()]
Der Thread T1, der [M.WaitOne()], ausführt, fordert den Besitz des Mutex M an. Wird M von keinem Thread gehalten, wird er T1 zugeteilt. Versucht danach ein Thread T2 dasselbe, wird er blockiert: Ein Mutex kann nur einem einzigen Thread gehören. T2 wird freigegeben, wenn T1 M freigibt. So können mehrere Threads blockiert sein, während sie auf M warten
[bool WaitOne(TimeSpan timeout)]
wie oben, aber das Warten ist auf [timeout] begrenzt. Die Methode gibt [false] zurück, wenn der Mutex nicht erworben werden konnte
[void ReleaseMutex()]
Der Thread, der M hält, gibt ihn frei. Einer der auf M wartenden Threads erwirbt ihn dann

Die Synchronisierung eines kritischen Abschnitts erfolgt wie folgt:

1
2
3
4
5
6
7
8
9
M.WaitOne();
try
{
    // der Thread ist der einzige, der hier eintritt: kritischer Abschnitt
}
finally
{
    M.ReleaseMutex();
}

Vergessen Sie nicht, einen Mutex freizugeben, sonst bleiben die darauf wartenden Threads dauerhaft blockiert. Deshalb erfolgt die Freigabe in einer [finally]-Anweisung, die unabhängig davon ausgeführt wird, ob eine Ausnahme aufgetreten ist. Das Programm [threads-09.cs] verwendet das vorige Beispiel mit einem Mutex:

// durch einen Mutex geschützter kritischer Abschnitt

// Prüfung des Arguments: die Anzahl der zu erzeugenden Threads
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-09.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// Erzeugung und Start der Threads
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// Warten auf das Ende der Threads
foreach (Thread thread in threads)
{
    thread.Join();
}
// Anzeige des Zählers
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// die gemeinsame Ressource
static class Counter
{
    // der Thread-Zähler
    public static int Value { get; private set; }
    // das Synchronisationsobjekt: ein Mutex
    private static readonly Mutex synchro = new();

    // die von jedem Thread ausgeführte Methode
    public static void Increment()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} waits for permission to enter the critical section");
        // wir fordern den Besitz des Mutex an
        synchro.WaitOne();
        try
        {
            // Lesen des Zählers
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // Warten
            Thread.Sleep(1000);
            // Inkrementieren des Zählers
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        finally
        {
            // wir geben den Mutex frei, mit oder ohne Exception
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} leaves the critical section");
            synchro.ReleaseMutex();
        }
    }
}

Anmerkungen:

  • Zeile 33: Das Objekt zur Thread-Synchronisierung ist nun ein Mutex;
  • Zeile 41: Beginn des kritischen Abschnitts. Der Thread wird blockiert, bis der Mutex frei ist;
  • Zeilen 42–57: Da ein Mutex immer freigegeben werden muss, unabhängig davon, ob eine Ausnahme auftritt, steht der kritische Abschnitt in einem [try], dessen [finally]-Klausel den Mutex freigibt (Zeile 57).

Ergebnisse:

> dotnet run threads-09.cs -- 3
At 11:36:28.858, thread 2 waits for permission to enter the critical section
At 11:36:28.906, thread 2 read the counter value: 0
At 11:36:28.858, thread 0 waits for permission to enter the critical section
At 11:36:28.858, thread 1 waits for permission to enter the critical section
At 11:36:29.907, thread 2 wrote the counter value: 1
At 11:36:29.907, thread 2 leaves the critical section
At 11:36:29.907, thread 0 read the counter value: 1
At 11:36:30.907, thread 0 wrote the counter value: 2
At 11:36:30.907, thread 0 leaves the critical section
At 11:36:30.907, thread 1 read the counter value: 2
At 11:36:31.908, thread 1 wrote the counter value: 3
At 11:36:31.908, thread 1 leaves the critical section
Number of threads generated: 3

Die Ergebnisse ähneln den vorherigen: Die Threads durchlaufen den kritischen Abschnitt einzeln nacheinander, und der endgültige Zählerwert ist korrekt.

Den wahren Wert des Mutex erkennt man bei einem benannten Mutex. Das Programm [threads-10.cs] wird zweimal in zwei verschiedenen Prozessen ausgeführt, die sich einen kritischen Abschnitt teilen:

// ein benannter Mutex synchronisiert Threads verschiedener Prozesse

// der Name des Mutex ist allen Prozessen bekannt, die ihn verwenden
const string mutexName = @"Global\csharp-course-threads-10";
// der Name des Prozesses wird als Argument übergeben
string process = args.Length > 0 ? args[0] : "P";

// wir öffnen den benannten Mutex (er wird erzeugt, falls er noch nicht existiert)
using var mutex = new Mutex(false, mutexName);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} requests the Mutex");
// Versuch ohne Warten
if (!mutex.WaitOne(TimeSpan.Zero))
{
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: the Mutex is held by another process, {process} waits");
    // Warten ohne Zeitlimit
    mutex.WaitOne();
}
try
{
    // kritischer Abschnitt zwischen Prozessen
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} obtained the Mutex, it works for 3 s");
    Thread.Sleep(3000);
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} releases the Mutex");
}
finally
{
    mutex.ReleaseMutex();
}

Anmerkungen:

  • Zeile 4: der Name des Mutex. Alle Prozesse, die einen Mutex mit diesem Namen öffnen, verwenden dasselbe Systemobjekt. Das Präfix [Global] legt fest, dass der Mutex für alle Sitzungen des Rechners sichtbar ist (das Standardpräfix [Local] beschränkt ihn auf die Sitzung des Benutzers);
  • Zeile 9: Der benannte Mutex wird erzeugt, falls er noch nicht existiert; andernfalls wird er geöffnet. Der erste Parameter, [false], gibt an, dass der Prozess bei der Erzeugung nicht den Besitz anfordert. Die [using]-Deklaration gibt das Objekt [Mutex] am Ende des Programms frei;
  • Zeile 12: Der Prozess versucht, den Mutex sofort zu erwerben ([TimeSpan.Zero]). Scheitert er, meldet er den Fehlschlag und wartet dann unbegrenzt darauf (Zeile 16);
  • Zeilen 18–27: der kritische Abschnitt, der 3 Sekunden dauert, gefolgt von der Freigabe des Mutex.

Das Aufzeichnungsskript startet Prozess A, wartet 1,5 Sekunden und startet dann Prozess B. Ergebnisse für Prozess A:

1
2
3
4
> dotnet run threads-10.cs -- A
11:36:35.438: process A requests the Mutex
11:36:35.486: process A obtained the Mutex, it works for 3 s
11:36:38.487: process A releases the Mutex

Ergebnisse von Prozess B:

1
2
3
4
5
> dotnet run threads-10.cs -- B
11:36:36.908: process B requests the Mutex
11:36:36.957: the Mutex is held by another process, B waits
11:36:38.487: process B obtained the Mutex, it works for 3 s
11:36:41.487: process B releases the Mutex

Prozess B fand den Mutex von Prozess A gehalten vor und wartete. Er erwarb ihn genau in dem Moment, in dem A ihn freigab. Eine übliche Verwendung eines benannten Mutex ist es, den Start zweier Instanzen derselben Anwendung zu verhindern: Die zweite Instanz, die den Mutex nicht erwerben kann, beendet sich sofort. Beendet sich ein Prozess, ohne einen von ihm gehaltenen Mutex freizugeben, spricht man von einem verwaisten Mutex: Der nächste Prozess, der [WaitOne] aufruft, erwirbt ihn, löst aber die Ausnahme [AbandonedMutexException] aus, um zu signalisieren, dass sich die geschützte Ressource in einem inkonsistenten Zustand befinden kann.

8.5.4. Die Klasse AutoResetEvent

Ein [AutoResetEvent]-Objekt ist eine Barriere, die jeweils nur einen Thread durchlässt. Es wird wie folgt erzeugt:

AutoResetEvent barrier = new AutoResetEvent(state);

Der boolesche Wert [state] gibt an, ob die Barriere geschlossen ([false]) oder offen ([true]) ist. Ein Thread, der die Barriere passieren möchte, gibt dies wie folgt an:

barrier.WaitOne();
  • Ist die Barriere offen, passiert der Thread sie, und die Barriere schließt sich automatisch hinter ihm (daher der Name der Klasse). Warten mehrere Threads, passiert nur einer;
  • ist die Barriere geschlossen, wird der Thread blockiert. Ein anderer Thread öffnet sie, wenn es an der Zeit ist. Dieser Zeitpunkt hängt ganz vom zu lösenden Problem ab. Die Barriere wird durch die folgende Operation geöffnet:
barrier.Set();

Ein Thread kann eine Barriere auch mit [barrier.Reset()] schließen. Anders als ein Mutex gehört eine Barriere keinem bestimmten Thread: Jeder Thread kann sie öffnen. Wenn wir im vorigen Beispiel den Mutex durch ein [AutoResetEvent] ersetzen, lautet der Code wie folgt [threads-11.cs]:

// durch eine AutoResetEvent-Barriere geschützter kritischer Abschnitt

// Prüfung des Arguments: die Anzahl der zu erzeugenden Threads
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-11.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// Erzeugung und Start der Threads
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// wir lassen die Threads an der geschlossenen Barriere ankommen
Thread.Sleep(500);
// wir öffnen die Barriere des kritischen Abschnitts
Thread.CurrentThread.Name = "Main";
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread Main opens the barrier of the critical section");
Counter.Synchro.Set();
// Warten auf das Ende der Threads
foreach (Thread thread in threads)
{
    thread.Join();
}
// Anzeige des Zählers
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// die gemeinsame Ressource
static class Counter
{
    // der Thread-Zähler
    public static int Value { get; private set; }
    // die Barriere, geschlossen (false) erzeugt
    public static readonly AutoResetEvent Synchro = new(false);

    // die von jedem Thread ausgeführte Methode
    public static void Increment()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} waits for permission to enter the critical section");
        // Passieren der Barriere: sie schließt sich hinter dem Thread wieder
        Synchro.WaitOne();
        try
        {
            // Lesen des Zählers
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // Warten
            Thread.Sleep(1000);
            // Inkrementieren des Zählers
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        finally
        {
            // wir öffnen die Barriere für einen weiteren Thread erneut
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} leaves the critical section");
            Synchro.Set();
        }
    }
}

Anmerkungen:

  • Zeile 39: Die Barriere wird im geschlossenen Zustand erzeugt. Sie wird vom Haupt-Thread in Zeile 23 geöffnet;
  • Zeile 19: Der Haupt-Thread wartet eine halbe Sekunde, damit die Threads an der Barriere ankommen können;
  • Zeile 47: Der Thread, der den Zähler erhöhen soll, fordert die Erlaubnis zum Eintritt in den kritischen Abschnitt an. Die verschiedenen Threads sammeln sich vor der geschlossenen Barriere. Wenn der Haupt-Thread sie öffnet, passiert einer der wartenden Threads, und die Barriere schließt sich wieder;
  • Zeile 63: Wenn der Thread seine Arbeit beendet hat, öffnet er die Barriere erneut und lässt so einen anderen Thread eintreten.

Ergebnisse:

> dotnet run threads-11.cs -- 3
At 11:36:43.413, thread 2 waits for permission to enter the critical section
At 11:36:43.407, thread 0 waits for permission to enter the critical section
At 11:36:43.411, thread 1 waits for permission to enter the critical section
At 11:36:43.914, thread Main opens the barrier of the critical section
At 11:36:43.915, thread 2 read the counter value: 0
At 11:36:44.915, thread 2 wrote the counter value: 1
At 11:36:44.915, thread 2 leaves the critical section
At 11:36:44.915, thread 0 read the counter value: 1
At 11:36:45.916, thread 0 wrote the counter value: 2
At 11:36:45.916, thread 0 leaves the critical section
At 11:36:45.916, thread 1 read the counter value: 2
At 11:36:46.916, thread 1 wrote the counter value: 3
At 11:36:46.916, thread 1 leaves the critical section
Number of threads generated: 3

Die Ergebnisse ähneln den vorherigen. Wir sehen, dass die drei Threads vor der Barriere warten, bis der Haupt-Thread sie öffnet (Zeile 5).

8.5.5. Die Klassen ManualResetEventSlim und SemaphoreSlim

Zwei weitere Synchronisierungswerkzeuge ergänzen die vorherigen.

Ein Objekt [ManualResetEventSlim] ist eine Barriere, die, sobald sie mit [Set] geöffnet wurde, offen bleibt und alle Threads passieren lässt, bis sie ausdrücklich mit [Reset] geschlossen wird. Das ist das „Startsignal“ für ein Rennen. Das Suffix [Slim] kennzeichnet die leichtgewichtigen Versionen der Synchronisierungswerkzeuge, die mit .NET 4 eingeführt wurden: Sie greifen nur bei längerem Warten auf das Betriebssystem zurück und funktionieren nur innerhalb eines Prozesses. Das Programm [threads-12.cs] lautet wie folgt:

// ManualResetEventSlim: eine Barriere, die alle wartenden Threads durchlässt

// die Barriere, geschlossen erzeugt
using var start = new ManualResetEventSlim(false);

// Erzeugung und Start von 4 Threads
var threads = new Thread[4];
for (int i = 0; i < threads.Length; i++)
{
    threads[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: runner {name} waits for the start signal");
        // Warten auf das Öffnen der Barriere
        start.Wait();
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: runner {name} has started");
    })
    { Name = i.ToString() };
    threads[i].Start();
}

// der Hauptthread wartet 1 s und gibt dann das Startsignal
Thread.Sleep(1000);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: start signal");
// die Barriere öffnet sich und bleibt offen: alle Threads passieren sie
start.Set();
// Warten auf das Ende der Threads
foreach (Thread thread in threads)
{
    thread.Join();
}
Console.WriteLine($"Is the barrier open? {start.IsSet}");

Anmerkungen:

  • Zeile 4: Die Barriere wird im geschlossenen Zustand erzeugt;
  • Zeile 15: Jeder Thread wartet darauf, dass die Barriere geöffnet wird;
  • Zeile 26: Der Haupt-Thread öffnet die Barriere nach einer Sekunde;
  • Zeile 32: Die Eigenschaft [IsSet] gibt an, ob die Barriere offen ist.

Ergebnisse:

> dotnet run threads-12.cs
11:36:48.866: runner 3 waits for the start signal
11:36:48.865: runner 0 waits for the start signal
11:36:48.866: runner 2 waits for the start signal
11:36:48.865: runner 1 waits for the start signal
11:36:49.865: start signal
11:36:49.865: runner 0 has started
11:36:49.865: runner 1 has started
11:36:49.865: runner 2 has started
11:36:49.865: runner 3 has started
Is the barrier open? True

Alle vier Läufer sind nach dem Startsignal millisekundengenau gemeinsam gestartet. Mit einem [AutoResetEvent], wäre nur einer gestartet.

Ein Semaphor ist eine Barriere mit einem Zähler: Sie lässt höchstens N Threads gleichzeitig in einen Codeabschnitt eintreten. Das ist nützlich, um die Nutzung einer nur begrenzt verfügbaren Ressource zu beschränken (Datenbankverbindungen, gleichzeitige Anfragen an einen Server usw.). Das Programm [threads-13.cs] lautet wie folgt:

// SemaphoreSlim: höchstens N Threads gleichzeitig in einem Codeabschnitt

// ein Semaphor mit 2 Plätzen
using var semaphore = new SemaphoreSlim(2);

// Erzeugung und Start von 5 Threads
var threads = new Thread[5];
for (int i = 0; i < threads.Length; i++)
{
    threads[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} waits for a slot");
        // wir fordern einen Platz an: blockierend, wenn keiner mehr frei ist
        semaphore.Wait();
        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} obtained a slot (free slots: {semaphore.CurrentCount})");
            // Arbeit
            Thread.Sleep(1000);
        }
        finally
        {
            // wir geben den Platz zurück
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} releases its slot");
            semaphore.Release();
        }
    })
    { Name = i.ToString() };
    threads[i].Start();
}
// Warten auf das Ende der Threads
foreach (Thread thread in threads)
{
    thread.Join();
}

Anmerkungen:

  • Zeile 4: Der Semaphor hat 2 Plätze;
  • Zeile 15: Ein Thread fordert einen Platz an. Ist einer verfügbar, belegt er ihn und fährt fort; andernfalls wird er blockiert, bis ein Platz frei wird;
  • Zeile 18: die Anzahl der noch verfügbaren Plätze;
  • Zeile 26: Der Thread gibt seinen Platz in einer [finally]-Klausel zurück.

Ergebnisse:

> dotnet run threads-13.cs
11:36:51.985: thread 3 waits for a slot
11:36:51.985: thread 1 waits for a slot
11:36:51.985: thread 0 waits for a slot
11:36:51.985: thread 4 waits for a slot
11:36:51.985: thread 2 waits for a slot
11:36:52.035: thread 3 obtained a slot (free slots: 0)
11:36:52.035: thread 2 obtained a slot (free slots: 0)
11:36:53.035: thread 2 releases its slot
11:36:53.037: thread 3 releases its slot
11:36:53.037: thread 1 obtained a slot (free slots: 0)
11:36:53.037: thread 4 obtained a slot (free slots: 0)
11:36:54.037: thread 1 releases its slot
11:36:54.037: thread 4 releases its slot
11:36:54.037: thread 0 obtained a slot (free slots: 1)
11:36:55.037: thread 0 releases its slot

Alle fünf Threads fordern einen Platz an; zwei erhalten sofort einen, die anderen drei warten. Jedes Mal, wenn ein Thread seinen Platz freigibt, erhält ihn ein wartender Thread. Es befinden sich nie mehr als zwei Threads im Codeabschnitt. Ein Semaphor mit einem einzigen Platz verhält sich wie ein Lock. Die Klasse [SemaphoreSlim] hat außerdem eine Methode [WaitAsync] , die sich mit [await] verwenden lässt, dem wir im nächsten Kapitel begegnen werden; die Klasse [Semaphore] (ohne [Slim]), die ressourcenintensiver ist, kann – wie [Mutex] – benannt und prozessübergreifend genutzt werden, jedoch nur unter Windows.

8.5.6. Die Klasse Interlocked

Die Klasse [Interlocked] macht einfache Operationen auf einer Variablen atomar: Die Operation wird vom Thread vollständig ausgeführt, ohne dass ein anderer Thread die Variable mitten in der Operation beobachten oder ändern könnte. Die bisherigen Werkzeuge ([lock], [Mutex], [AutoResetEvent]) sind alle darauf ausgelegt, eine Gruppe von Operationen atomar zu machen, auf Kosten der Blockierung anderer Threads. Für einfache, aber häufige Operationen vermeidet die Klasse [Interlocked] diese Blockierung durch spezielle Prozessoranweisungen. Ihre wichtigsten statischen Methoden sind die folgenden:

Methode
Aufgabe
[int Increment(ref int x)]
erhöht [x] um 1 und gibt den neuen Wert zurück
[int Decrement(ref int x)]
verringert [x] um 1 und gibt den neuen Wert zurück
[int Add(ref int x, int value)]
addiert [value] zu [x] und gibt den neuen Wert zurück
[int Exchange(ref int x, int value)]
weist [value] an [x] zu und gibt den alten Wert zurück
[int CompareExchange(ref int x, int value, int comparand)]
weist [value] nur dann an [x] zu, wenn [x] gleich [comparand] ist; gibt den vorherigen Wert von [x] zurück
[long Read(ref long x)]
liest atomar einen 64-Bit-Wert (nützlich auf einem 32-Bit-Prozessor)

Diese Methoden stehen für die Typen [int], [long], [uint], [ulong] und – für [Exchange] und [CompareExchange] – für andere Typen zur Verfügung. Die Methoden [And] und [Or] (.NET 5) führen atomar eine bitweise „Und“- bzw. „Oder“-Operation aus. Der Parameter wird als Referenz übergeben ([ref]): [Interlocked] muss auf der Variablen selbst arbeiten, nicht auf einer Kopie. Aus diesem Grund muss die Variable ein Feld oder eine lokale Variable sein; eine Eigenschaft kann nicht als Referenz übergeben werden.

Das Programm [threads-14.cs] baut auf dem Experiment des Programms [threads-07.cs] auf und vergleicht drei Möglichkeiten, den gemeinsamen Zähler zu erhöhen:

// die Klasse Interlocked: atomare Operationen ohne Lock

using System.Diagnostics;

// Parameter: Anzahl der Threads, Anzahl der Inkremente pro Thread
int nbThreads = args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4;
int nbIncrements = args.Length > 1 && int.TryParse(args[1], out int m) ? m : 10_000_000;
Console.WriteLine($"{nbThreads} threads, {nbIncrements:N0} increments per thread, expected value {nbThreads * nbIncrements:N0}");

// drei Möglichkeiten, den gemeinsamen Zähler zu inkrementieren
Measure("without synchronization", Counter.WithoutSynchronization);
Measure("with lock", Counter.WithLock);
Measure("with Interlocked", Counter.WithInterlocked);

// startet die Threads, die alle [increment] nbIncrements-mal ausführen
void Measure(string method, Action increment)
{
    Counter.Value = 0;
    // eine Barriere, damit alle Threads gleichzeitig starten
    using var start = new ManualResetEventSlim(false);
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++)
    {
        threads[i] = new Thread(() =>
        {
            start.Wait();
            for (int j = 0; j < nbIncrements; j++)
            {
                increment();
            }
        });
        threads[i].Start();
    }
    // los!
    var stopwatch = Stopwatch.StartNew();
    start.Set();
    foreach (Thread thread in threads)
    {
        thread.Join();
    }
    stopwatch.Stop();
    Console.WriteLine($"{method,-23}: obtained value {Counter.Value,12:N0} in {stopwatch.ElapsedMilliseconds,5} ms");
}

// die gemeinsame Ressource
static class Counter
{
    // ein Feld (und keine Eigenschaft), damit es als Referenz übergeben werden kann
    public static int Value;
    private static readonly Lock padlock = new();

    // lesen, inkrementieren, schreiben: nicht atomar
    public static void WithoutSynchronization() => Value++;

    // durch ein Lock geschützter kritischer Abschnitt
    public static void WithLock()
    {
        lock (padlock)
        {
            Value++;
        }
    }

    // atomares Inkrementieren, ohne Lock
    public static void WithInterlocked() => Interlocked.Increment(ref Value);
}

Anmerkungen:

  • Zeile 3: Die Klasse [Stopwatch], die Zeitdauern misst, befindet sich im Namensraum [System.Diagnostics];
  • Zeilen 11–13: Die lokale Funktion [Measure] wird mit drei verschiedenen Erhöhungsmethoden aufgerufen, die als Delegat [Action] übergeben werden;
  • Zeilen 16–42: Die Funktion [Measure] startet [nbThreads] Threads, die jeweils die erhaltene Methode [nbIncrements] -mal aufrufen, und misst die Gesamtzeit mit einer [Stopwatch]. Das Format [{Counter.Value,12:N0}] richtet den Wert auf 12 Zeichen rechtsbündig aus;
  • Zeilen 20–26 und 36: Die Threads warten alle hinter einer [ManualResetEventSlim]-Barriere, die sich öffnet, sobald alle gestartet wurden. So können sie ihre Arbeit gleichzeitig beginnen, wodurch gleichzeitige Zugriffe sehr viel wahrscheinlicher sind als bei nacheinander gestarteten Threads;
  • Zeile 49: Der Zähler ist ein Feld und keine Eigenschaft, damit er per Referenz an [Interlocked.Increment] übergeben werden kann;
  • Zeile 53: die nicht synchronisierte Erhöhung;
  • Zeilen 56–60: Erhöhung innerhalb eines kritischen Abschnitts, der durch ein [Lock] geschützt ist;
  • Zeile 65: atomare Erhöhung.

Ergebnisse:

1
2
3
4
5
> dotnet run threads-14.cs
4 threads, 10,000,000 increments per thread, expected value 40,000,000
without synchronization: obtained value   26,108,241 in   289 ms
with lock              : obtained value   40,000,000 in  2484 ms
with Interlocked       : obtained value   40,000,000 in   754 ms
  • Ohne Synchronisierung ist das Ergebnis wieder einmal falsch;
  • die beiden anderen Methoden liefern das richtige Ergebnis;
  • [Interlocked] ist in diesem Durchlauf deutlich schneller als [lock] . Das Lock ist hier teuer, weil vier Threads ständig um dasselbe Lock für eine winzige Operation konkurrieren. Die gemessenen Zeiten hängen stark vom Rechner und seiner Auslastung ab: Nur ihre Größenordnung ist aussagekräftig.

Die Methode [CompareExchange] ist der Baustein „sperrfreier“ Algorithmen: den Wert lesen, den neuen berechnen und ihn nur dann schreiben, wenn sich die Variable in der Zwischenzeit nicht geändert hat; andernfalls von vorn beginnen. Die später vorgestellten nebenläufigen Sammlungen nutzen sie intensiv.

8.6. Gleichzeitiger Zugriff auf mehrere gemeinsame Ressourcen

8.6.1. Deadlock

In unseren bisherigen Beispielen wurde nur eine einzige Ressource von den verschiedenen Threads gemeinsam genutzt. Die Situation wird komplizierter, wenn es mehrere Ressourcen gibt, die voneinander abhängen. Insbesondere kann ein Deadlock auftreten: Zwei Threads warten aufeinander. Betrachten wir die folgenden Aktionen, die nacheinander ablaufen:

  • Ein Thread T1 erwirbt das Lock V1, um auf eine gemeinsame Ressource R1 zuzugreifen;
  • ein Thread T2 erwirbt das Lock V2, um auf eine gemeinsame Ressource R2 zuzugreifen;
  • der Thread T1 fordert das Lock V2 an. Er wird blockiert;
  • der Thread T2 fordert das Lock V1 an. Er wird blockiert.

Die Threads T1 und T2 warten unbegrenzt aufeinander. Es sind mehrere Lösungen möglich:

  • beide Ressourcen gleichzeitig mit einem einzigen Lock anfordern. Das ist nicht immer möglich, wenn dadurch eine teure Ressource lange gesperrt wird;
  • Locks immer in derselben Reihenfolge erwerben: Wenn alle Threads V1 vor V2 erwerben, ist ein Deadlock unmöglich. Das ist die am häufigsten verwendete Regel;
  • ein Thread, der V1 hält und V2 nicht erwerben kann, gibt V1 frei, um einen Deadlock zu vermeiden.

Das Programm [threads-15.cs] verursacht einen Deadlock und implementiert die letzte Lösung:

// Deadlock: zwei Threads nehmen zwei Locks in unterschiedlicher Reihenfolge

// die beiden gemeinsamen Ressourcen und ihre Locks
Lock lockR1 = new();
Lock lockR2 = new();

// T1 nimmt R1 und fordert dann R2 an; nach 2 s gibt es auf
var t1 = new Thread(() => Work(lockR1, "R1", lockR2, "R2", TimeSpan.FromSeconds(2))) { Name = "T1" };
// T2 nimmt R2 und fordert dann R1 an; es wartet bis zu 5 s
var t2 = new Thread(() => Work(lockR2, "R2", lockR1, "R1", TimeSpan.FromSeconds(5))) { Name = "T2" };
t1.Start();
t2.Start();
t1.Join();
t2.Join();
Console.WriteLine("End of Main");

// nimmt die 1. Ressource und versucht dann, während [timeout] die 2. zu nehmen
static void Work(Lock first, string firstName, Lock second, string secondName, TimeSpan timeout)
{
    string name = Thread.CurrentThread.Name ?? "?";
    lock (first)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} obtained {firstName}");
        // wir geben dem anderen Thread Zeit, seine erste Ressource zu nehmen
        Thread.Sleep(500);
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} requests {secondName}");
        // Anforderung mit maximaler Wartezeit, statt eines Locks, das unbegrenzt warten würde
        if (second.TryEnter(timeout))
        {
            try
            {
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} obtained {secondName} and works with {firstName} and {secondName}");
            }
            finally
            {
                second.Exit();
            }
        }
        else
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} did not obtain {secondName} within {timeout.TotalSeconds} s: it releases {firstName} and gives up");
        }
    }
}

Anmerkungen:

  • Zeilen 4–5: die Locks auf den beiden Ressourcen. Hier sind es lokale Variablen, die von den Lambdas in den Zeilen 8–10 erfasst werden;
  • Zeile 8: Der Thread T1 erwirbt R1 und fordert dann R2 an; er wartet höchstens 2 Sekunden;
  • Zeile 10: Der Thread T2 nimmt R2 und fordert dann R1 an – also in umgekehrter Reihenfolge; er wartet höchstens 5 Sekunden;
  • Zeile 21: Der Thread erwirbt seine erste Ressource;
  • Zeile 25: Er wartet eine halbe Sekunde, wodurch der andere Thread Zeit hat, seine eigene erste Ressource zu erwerben: Der Deadlock ist dann sicher;
  • Zeile 28: Statt eines [lock] , das unbegrenzt warten würde, fordert der Thread das zweite Lock mit einer maximalen Wartezeit an. [TryEnter] gibt [true] zurück, wenn das Lock erworben wurde, oder [false] , wenn die Wartezeit abgelaufen ist;
  • Zeile 36: Ein mit [TryEnter] erworbenes Lock muss mit [Exit] in einer [finally]-Klausel freigegeben werden;
  • Zeilen 39–41: Konnte das zweite Lock nicht erworben werden, bricht der Thread ab. Beim Verlassen des [lock]-Blocks gibt er seine erste Ressource frei.

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run threads-15.cs
11:37:01.001: T1 obtained R1
11:37:01.001: T2 obtained R2
11:37:01.549: T1 requests R2
11:37:01.549: T2 requests R1
11:37:03.550: T1 did not obtain R2 within 2 s: it releases R1 and gives up
11:37:03.550: T2 obtained R1 and works with R2 and R1
End of Main

Jeder der beiden Threads hat seine erste Ressource erworben und dann die zweite angefordert: Sie befinden sich in einem Deadlock. Nach 2 Sekunden gibt T1 auf und gibt R1 frei; T2, der noch wartete, erhält sofort R1 und kann seine Arbeit verrichten. Ohne Wartezeit wäre das Programm nie beendet worden.

8.6.2. Ein Beispiel: Leser und Schreiber

Betrachten wir das folgende Beispiel:

  • Wir haben ein Array, in das einige Threads Daten schreiben (die Schreiber) und aus dem andere sie lesen (die Leser);
  • die Schreiber sind untereinander gleichberechtigt, aber exklusiv: Es kann immer nur ein Schreiber Daten im Array ablegen;
  • die Leser sind untereinander gleichberechtigt, aber exklusiv: Es kann immer nur ein Leser die im Array gespeicherten Daten lesen;
  • ein Leser kann nur dann Daten aus dem Array lesen, wenn ein Schreiber welche dort abgelegt hat, und ein Schreiber kann nur dann neue Daten im Array ablegen, wenn die dort vorhandenen Daten von einem Leser gelesen wurden.

Es gibt zwei Arten gemeinsamer Ressourcen:

  • das Array, in das geschrieben wird: Nur ein Schreiber darf gleichzeitig darauf zugreifen;
  • das Array, aus dem gelesen wird: Nur ein Leser darf gleichzeitig darauf zugreifen.

und eine Reihenfolge für die Nutzung dieser Ressourcen:

  • Ein Leser muss immer auf einen Schreiber folgen;
  • ein Schreiber muss immer auf einen Leser folgen, außer beim ersten Mal.

Der Zugriff auf diese beiden Ressourcen lässt sich mit zwei Barrieren vom Typ [AutoResetEvent] steuern:

  • Die Barriere [canWrite] steuert den Zugriff der Schreiber auf das Array;
  • die Barriere [canRead] steuert den Zugriff der Leser auf das Array;
  • die Barriere [canWrite] wird offen erzeugt, sodass der erste Schreiber passieren kann und alle anderen blockiert werden;
  • Die Barriere [canRead] wird im geschlossenen Zustand erzeugt und blockiert alle Leser;
  • wenn ein Schreiber seine Arbeit beendet hat, öffnet er die Barriere [canRead] , um einen Leser hereinzulassen;
  • wenn ein Leser seine Arbeit beendet hat, öffnet er die Barriere [canWrite] , um einen Schreiber hereinzulassen.

Das Programm [threads-16.cs] , das diese Synchronisation veranschaulicht, lautet wie folgt:

// Leser und Schreiber, durch zwei AutoResetEvent-Barrieren synchronisiert

// die Anzahl der Threads jeder Art
const int nbThreads = 2;

// Erzeugung und Start der Leser-Threads
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Read) { Name = $"R{i}" }.Start();
}
// Erzeugung und Start der Schreiber-Threads
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Write) { Name = $"W{i}" }.Start();
}
// Ende von Main: die anderen Threads setzen ihre Arbeit fort
Console.WriteLine("End of Main...");

// die gemeinsame Ressource und ihre Synchronisation
static class Board
{
    // das zwischen Lesern und Schreibern gemeinsam genutzte Array
    private static readonly int[] data = new int[3];
    // signalisiert, dass der Inhalt von data gelesen werden kann: anfangs geschlossen
    private static readonly AutoResetEvent canRead = new(false);
    // signalisiert, dass data geschrieben werden kann: anfangs offen
    private static readonly AutoResetEvent canWrite = new(true);

    // den Inhalt des Arrays lesen
    public static void Read()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Read] started by thread {name}");
        // wir warten auf die Leseerlaubnis
        canRead.WaitOne();
        // Lesen des Arrays
        for (int i = 0; i < data.Length; i++)
        {
            // 0,5 s warten: der Thread verliert den Prozessor
            Thread.Sleep(500);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: reader {name} read the number {data[i]}");
        }
        // wir erlauben einem Schreiber den Zugriff
        canWrite.Set();
        Console.WriteLine($"Method [Read] finished by thread {name}");
    }

    // in das Array schreiben
    public static void Write()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Write] started by thread {name}");
        // wir warten auf die Schreiberlaubnis
        canWrite.WaitOne();
        // Schreiben des Arrays
        for (int i = 0; i < data.Length; i++)
        {
            // 0,5 s warten
            Thread.Sleep(500);
            // Random.Shared kann von mehreren Threads verwendet werden
            data[i] = Random.Shared.Next(0, 1000);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: writer {name} wrote the number {data[i]}");
        }
        // wir erlauben einem Leser den Zugriff
        canRead.Set();
        Console.WriteLine($"Method [Write] finished by thread {name}");
    }
}

Kommentare:

  • Zeilen 7–14: Erzeugung und Start von zwei Leser-Threads, gefolgt von zwei Schreiber-Threads. Es werden keine Verweise auf die Threads gehalten: Der Hauptthread wartet nicht auf sie;
  • Zeile 17: Der Hauptthread endet sofort. Der Prozess läuft weiter, bis alle vier Threads – bei denen es sich um Vordergrund-Threads handelt – beendet sind;
  • Zeile 23: Das Array [data] ist die gemeinsam genutzte Ressource der Leser- und Schreiber-Threads;
  • Zeile 25: Die Barriere [canRead] signalisiert den Lesern, dass sie das Array lesen dürfen. Sie wird von dem Schreiber geöffnet, der das Array gefüllt hat. Sie wird im geschlossenen Zustand erzeugt: Zuerst muss ein Schreiber das Array füllen;
  • Zeile 27: Die Barriere [canWrite] teilt den Schreibern mit, dass sie in das Array schreiben dürfen. Sie wird von dem Leser geöffnet, der das gesamte Array gelesen hat. Sie wird im offenen Zustand erzeugt: Das Array ist von Anfang an beschreibbar;
  • Zeile 35: Ein Leser wartet darauf, dass ein Schreiber signalisiert, dass das Array gefüllt wurde. Wenn dieses Signal eintrifft, fährt nur einer der wartenden Leser fort;
  • Zeilen 37–41: Das Array wird gelesen, mit einer halben Sekunde Pause bei jedem Element, damit der Thread die CPU abgeben muss;
  • Zeile 44: Der Leser teilt den Schreibern mit, dass das Array gelesen wurde und erneut gefüllt werden kann;
  • die Methode [Write] verhält sich symmetrisch zur Methode [Read];
  • Zeile 61: Die geschriebenen Zahlen werden zufällig erzeugt. Die Eigenschaft [Random.Shared] (.NET 6) stellt einen gemeinsamen Generator bereit, der von mehreren Threads sicher verwendet werden kann. Im Kurs von 2008 wurde ein gewöhnliches Objekt [Random] von mehreren Threads gemeinsam genutzt, dessen Methoden nicht dafür ausgelegt sind, gleichzeitig von mehreren Threads aufgerufen zu werden.

Ergebnisse:

> dotnet run threads-16.cs
Method [Read] started by thread R1
Method [Read] started by thread R0
Method [Write] started by thread W0
Method [Write] started by thread W1
End of Main...
11:37:06.185: writer W0 wrote the number 359
11:37:06.719: writer W0 wrote the number 226
11:37:07.219: writer W0 wrote the number 693
Method [Write] finished by thread W0
11:37:07.719: reader R0 read the number 359
11:37:08.220: reader R0 read the number 226
11:37:08.720: reader R0 read the number 693
Method [Read] finished by thread R0
11:37:09.220: writer W1 wrote the number 325
11:37:09.720: writer W1 wrote the number 935
11:37:10.221: writer W1 wrote the number 96
Method [Write] finished by thread W1
11:37:10.721: reader R1 read the number 325
11:37:11.221: reader R1 read the number 935
11:37:11.722: reader R1 read the number 96
Method [Read] finished by thread R1

Folgende Punkte sind bemerkenswert:

  • Es gibt immer nur einen Leser gleichzeitig, obwohl dieser Leser im kritischen Abschnitt [Read] den Prozessor verliert;
  • es gibt immer nur einen Schreiber gleichzeitig, obwohl dieser im kritischen Abschnitt [Write] den Prozessor verliert;
  • ein Leser liest nur, wenn im Array etwas zu lesen ist;
  • ein Schreiber schreibt nur, wenn das Array vollständig gelesen wurde;
  • die Ausführungsreihenfolge lässt sich jedoch nicht steuern: Es gab keinen Grund, warum der Schreiber W0 vor dem Schreiber W1 oder der Leser R0 vor dem Leser R1 an die Reihe kommen sollte. Eine andere Ausführung kann eine andere Reihenfolge ergeben.

8.6.3. Die Klasse Monitor

Wenn im vorherigen Beispiel die Schreiber an der Anweisung [canWrite.WaitOne()] blockiert sind, wird einer von ihnen – ein beliebiger – durch die Operation [canWrite.Set()] freigegeben. Wenn Sie die Barriere für einen bestimmten Schreiber öffnen möchten, wird es komplizierter.

Stellen Sie sich als Analogie eine Behörde mit Schaltern vor. Wenn ein Kunde ankommt, zieht er an einem Automaten eine nummerierte Wartemarke und setzt sich dann hin. Die Kunden werden per Lautsprecher mit ihrer Nummer aufgerufen. Während des Wartens kann der Kunde tun, was er möchte: lesen oder dösen. Er wird jedes Mal geweckt, wenn der Lautsprecher eine Nummer ausruft. Ist es seine Nummer, steht der Kunde auf und geht zum Schalter; andernfalls wendet er sich wieder seiner vorherigen Beschäftigung zu. Mit Threads können wir auf ähnliche Weise vorgehen. Nehmen wir das Beispiel der Schreiber:

Am Schalter
Bei Threads
mehrere Schreiber warten auf denselben Schalter
ihre Threads sind blockiert
der Schalter wird frei und die Nummer des nächsten Schreibers wird aufgerufen
der Thread, der das Array gelesen hat, teilt den Schreibern mit, dass das Array verfügbar ist. Entweder dieser oder ein anderer Thread hat bestimmt, welcher Schreiber an der Reihe ist
Jeder Schreiber prüft seine Nummer; nur der Schreiber mit der aufgerufenen Nummer geht zum Schalter, die anderen kehren in die Warteschlange zurück
Jeder Thread prüft, ob er der ausgewählte ist. Wenn ja, passiert er die Barriere, andernfalls kehrt er in die Warteschlange zurück

Die Klasse [Monitor] implementiert dieses Szenario. Ihre statischen Methoden lauten wie folgt:

Methode
Rolle
[Enter(object token)]
Fordert das Token an: Der Thread erhält es, wenn es frei ist; andernfalls wird er blockiert, bis es frei wird
[bool TryEnter(object token, TimeSpan timeout)]
Wie oben, jedoch mit einer maximalen Wartezeit
[Exit(object token)]
gibt das Token zurück
[bool Wait(object token)]
gibt das Token zurück und blockiert den Thread, bis ein anderer Thread über [Pulse] oder [PulseAll] eine Änderung signalisiert; der Thread muss dann das Token zurückerhalten, bevor er fortfahren kann
[Pulse(object token)]
weckt einen der Threads auf, die durch [Wait] auf diesem Token blockiert sind
[PulseAll(object token)]
weckt alle Threads auf, die durch [Wait] auf diesem Token blockiert sind

Wir beschreiben nun ein Standardmuster, das im Kapitel „Threading“ des Buches von J. und B. Albahari, [C# in a Nutshell], vorgeschlagen wird und Barriereprobleme mit einer Eintrittsbedingung lösen kann.

Threads, die sich eine Ressource (den Schalter) teilen, greifen darauf über ein Objekt zu, das wir Token nennen. Um die Barriere zum Schalter zu passieren, muss man das Token besitzen, und es gibt nur eines. Die Threads müssen sich das Token daher gegenseitig weiterreichen:

object token = new();

Um zum Schalter zu gehen, fordert ein Thread zunächst das Token mit [Monitor.Enter(token)] an, oder einfacher mit einer [lock]-Klausel. Erhält er das Token, prüft er, ob er die Bedingung für den Zugang zum Schalter erfüllt:

1
2
3
4
5
6
7
8
9
lock (token)
{
    while (!iAmTheOneExpected)
    {
        Monitor.Wait(token);
    }
    // Gang zum Schalter
    ...
}

Ist der Thread nicht derjenige, der am Schalter erwartet wird, gibt er seinen Platz auf, indem er das Token über [Monitor.Wait(token)] zurückgibt und in einen blockierten Zustand wechselt. Er wird geweckt, sobald ein anderer Thread eine Änderung der Zugangsbedingung signalisiert; dann erhält er das Token zurück und prüft die Bedingung erneut. Deshalb ist die Prüfung eine Schleife ([while]) und kein einfaches [if]. Die Operation [Monitor.Wait(token)] kann nur von einem Thread ausgeführt werden, der das Token besitzt; andernfalls wird eine Ausnahme vom Typ [SynchronizationLockException] ausgelöst. In diesem Szenario wird das Token erst nach Abschluss der Operation freigegeben.

Der Thread, der die Zugangsbedingung für den Schalter ändert, muss ebenfalls das Token besitzen und die wartenden Threads benachrichtigen:

1
2
3
4
5
6
7
lock (token)
{
    // die Zugriffsbedingung für den Schalter ändern
    ...
    // die auf das Token wartenden Threads aufwecken
    Monitor.PulseAll(token);
}

Das Aufwecken der Threads bedeutet, dass die wartenden Threads zu Kandidaten für das Token werden; sie erhalten es nicht sofort. Das Token ist erst am Ende des [lock]-Blocks verfügbar. Alle aufgeweckten Threads erhalten das Token dann nacheinander in unbestimmter Reihenfolge und haben so die Möglichkeit, die Zugangsbedingung erneut zu prüfen. Der erste, der die Bedingung erfüllt, behält das Token und geht zum Schalter.

Ein wichtiger Hinweis: Die Methoden [Wait], [Pulse] und [PulseAll] von [Monitor] gelten für ein Objekt, das durch [lock (obj)] or [Monitor.Enter(obj)] gesperrt wurde. Mit dem Typ [Lock] von .NET 9 funktionieren sie nicht; dieser hat kein Äquivalent. Die Token in diesem Abschnitt sind daher Objekte vom Typ [object].

Mit diesem Wissen können wir die Leser-Schreiber-Anwendung neu schreiben und dabei die Reihenfolge festlegen, in der Leser und Schreiber ihre jeweiligen Schalter erreichen [threads-17.cs]:

// Leser und Schreiber, die in vorgegebener Reihenfolge zum Schalter gehen: Monitor.Wait / Monitor.PulseAll

// die Anzahl der Threads jeder Art
const int nbThreads = 3;

// die Reihenfolge der Leser: umgekehrt zur Erzeugungsreihenfolge
Board.ReadOrder = [.. Enumerable.Range(0, nbThreads).Select(i => $"R{nbThreads - 1 - i}")];
// die Reihenfolge der Schreiber: die Erzeugungsreihenfolge
Board.WriteOrder = [.. Enumerable.Range(0, nbThreads).Select(i => $"W{i}")];
for (int i = 0; i < nbThreads; i++)
{
    Console.WriteLine($"Reader {Board.ReadOrder[i]} is in position {i}, writer {Board.WriteOrder[i]} is in position {i}");
}

// Erzeugung und Start der Leser-Threads, dann der Schreiber-Threads
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Read) { Name = $"R{i}" }.Start();
}
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Write) { Name = $"W{i}" }.Start();
}

// Schreiberlaubnis
Board.AllowWriting();
// Ende von Main
Console.WriteLine("End of Main...");

// die gemeinsame Ressource und ihre Synchronisation
static class Board
{
    // das zwischen Lesern und Schreibern gemeinsam genutzte Array
    private static readonly int[] data = new int[3];
    // die Zugriffstokens der Lese- und Schreibschalter
    private static readonly object canRead = new();
    private static readonly object canWrite = new();
    // die Zugriffsbedingungen der Schalter
    private static bool readingAllowed = false;
    private static bool writingAllowed = false;
    private static int nextReader = 0;
    private static int nextWriter = 0;
    // die Reihenfolge der Leser und der Schreiber
    public static string[] ReadOrder { get; set; } = [];
    public static string[] WriteOrder { get; set; } = [];

    // öffnet den Schreibschalter
    public static void AllowWriting()
    {
        lock (canWrite)
        {
            writingAllowed = true;
            // wir wecken alle Schreiber auf, die auf das Token warten
            Monitor.PulseAll(canWrite);
        }
    }

    // den Inhalt des Arrays lesen
    public static void Read()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Read] started by thread {name}");
        // wir fordern das Token des Leseschalters an
        lock (canRead)
        {
            // solange wir nicht an der Reihe sind, geben wir das Token zurück und warten
            while (!readingAllowed || ReadOrder[nextReader] != name)
            {
                Monitor.Wait(canRead);
            }
            // am Schalter: Lesen des Arrays
            for (int i = 0; i < data.Length; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: reader {name} read the number {data[i]}");
            }
            // nächster Leser
            readingAllowed = false;
            nextReader++;
            // wir benachrichtigen die Schreiber, dass sie schreiben können
            lock (canWrite)
            {
                writingAllowed = true;
                Monitor.PulseAll(canWrite);
            }
            Console.WriteLine($"Method [Read] finished by thread {name}");
        }
    }

    // in das Array schreiben
    public static void Write()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Write] started by thread {name}");
        // wir fordern das Token des Schreibschalters an
        lock (canWrite)
        {
            // solange wir nicht an der Reihe sind, geben wir das Token zurück und warten
            while (!writingAllowed || WriteOrder[nextWriter] != name)
            {
                Monitor.Wait(canWrite);
            }
            // am Schalter: Schreiben des Arrays
            for (int i = 0; i < data.Length; i++)
            {
                Thread.Sleep(500);
                data[i] = Random.Shared.Next(0, 1000);
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: writer {name} wrote the number {data[i]}");
            }
            // nächster Schreiber
            writingAllowed = false;
            nextWriter++;
            // wir benachrichtigen die Leser, dass sie lesen können
            lock (canRead)
            {
                readingAllowed = true;
                Monitor.PulseAll(canRead);
            }
            Console.WriteLine($"Method [Write] finished by thread {name}");
        }
    }
}

Der Zugang zum Leseschalter wird durch die folgenden Elemente bedingt:

  • Zeile 36: das Token [canRead];
  • Zeile 39: der Boolesche Wert [readingAllowed];
  • Zeile 44: das sortierte Array der Leser-Namen. Die Leser gehen in der durch dieses Array festgelegten Reihenfolge zur Lesestation;
  • Zeile 41: [nextReader] ist der Index des nächsten Lesers in diesem Array, der zum Schalter gehen darf.

Der Zugang zum Schreibschalter wird auf ähnliche Weise durch das Token [canWrite], den Booleschen Wert [writingAllowed], das Array [WriteOrder] und den Index [nextWriter] gesteuert.

Das Hauptprogramm:

  • Zeilen 7–9: Die Leser gehen in umgekehrter Reihenfolge ihrer Erzeugung zum Schalter (R2, R1, R0), die Schreiber in der Reihenfolge ihrer Erzeugung (W0, W1, W2). Die Arrays werden mit einem Collection-Ausdruck [.. sequence] erstellt, der aus einer LINQ-Abfrage ein Array erzeugt;
  • Zeilen 18–22: Erzeugung und Initialisierung der Leser, danach der Schreiber. Sie sind alle blockiert, da weder Lesen noch Schreiben erlaubt ist;
  • Zeile 26: Das Schreiben wird freigegeben, und die Schreiber werden benachrichtigt, dass sich etwas geändert hat (Methode [AllowWriting], Zeilen 48–54).

Die Methode [Read]:

  • Zeilen 64–86: Der gesamte Ablauf an der Lesestation wird durch [lock] auf das Token [canRead] gesteuert. Der Leser, der es erhält, behält es während seines gesamten Aufenthalts an der Station;
  • Zeilen 67–69: Ein Leser, der das Token erhalten hat, gibt es zurück, wenn das Lesen nicht erlaubt ist oder er nicht an der Reihe ist;
  • Zeilen 72–75: Durchgang durch die Station (Lesen der Tabelle);
  • Zeilen 78–79: Der Leser ändert die Zugangsbedingungen für den Leseschalter. Er besitzt weiterhin das Lese-Token, und diese Änderungen verhindern, dass ein anderer Leser den Schalter erreicht;
  • Zeilen 81–84: Der Leser ändert die Zugangsbedingungen für den Schreibschalter und benachrichtigt alle wartenden Schreiber, dass sich etwas geändert hat. Dazu nimmt er das Token [canWrite]: Hier sehen wir, dass der Thread zwei Token gleichzeitig besitzt. Die Schreiber gehen in umgekehrter Reihenfolge vor (sie besitzen [canWrite] und fordern [canRead] an), was der oben beschriebenen Deadlock-Situation entspricht. Hier besteht jedoch keine Gefahr: Ein Thread fordert das zweite Token erst am Ende seines Besuchs am Schalter an; die beiden Schalter sind nie gleichzeitig besetzt; und die anderen Threads halten ein Token nur so lange, wie sie zur Prüfung der Zugangsbedingung brauchen, ohne das andere Token anzufordern.

Die Methode [Write] verhält sich symmetrisch zur Methode [Read]. Im Kurs von 2008 wurde im Hauptprogramm [Monitor.Pulse] verwendet, das nur einen einzigen Thread weckt: Wäre dieser Thread nicht der erwartete Schreiber gewesen, hätte er sich wieder schlafen gelegt, und der erwartete Schreiber wäre möglicherweise nie geweckt worden. Bei einer Zugangsbedingung, die einen bestimmten Thread vorschreibt, müssen Sie [PulseAll] verwenden.

Hier ein Ausführungsbeispiel:

> dotnet run threads-17.cs
Reader R2 is in position 0, writer W0 is in position 0
Reader R1 is in position 1, writer W1 is in position 1
Reader R0 is in position 2, writer W2 is in position 2
Method [Read] started by thread R0
Method [Read] started by thread R1
Method [Read] started by thread R2
End of Main...
Method [Write] started by thread W0
Method [Write] started by thread W2
Method [Write] started by thread W1
11:37:14.240: writer W0 wrote the number 550
11:37:14.789: writer W0 wrote the number 13
11:37:15.290: writer W0 wrote the number 5
Method [Write] finished by thread W0
11:37:15.790: reader R2 read the number 550
11:37:16.290: reader R2 read the number 13
11:37:16.791: reader R2 read the number 5
Method [Read] finished by thread R2
11:37:17.291: writer W1 wrote the number 962
11:37:17.791: writer W1 wrote the number 475
11:37:18.292: writer W1 wrote the number 167
Method [Write] finished by thread W1
11:37:18.792: reader R1 read the number 962
11:37:19.292: reader R1 read the number 475
11:37:19.793: reader R1 read the number 167
Method [Read] finished by thread R1
11:37:20.293: writer W2 wrote the number 849
11:37:20.793: writer W2 wrote the number 31
11:37:21.294: writer W2 wrote the number 817
Method [Write] finished by thread W2
11:37:21.794: reader R0 read the number 849
11:37:22.295: reader R0 read the number 31
11:37:22.795: reader R0 read the number 817
Method [Read] finished by thread R0

Schreiber und Leser kommen an ihren jeweiligen Schaltern abwechselnd an die Reihe, jeweils in der vorgegebenen Reihenfolge: W0, R2, W1, R1, W2, R0.

8.7. Nebenläufige Collections

Die bisherigen Beispiele schützten sehr einfache gemeinsame Daten (einen Zähler, ein Array). Wenn Threads eine Collection (Liste, Dictionary, Queue) gemeinsam nutzen, könnte man jeden Zugriff mit einem [lock] schützen. Gewöhnliche Collections ([List<T>], [Dictionary<TKey,TValue>], [Queue<T>]) sind jedoch nicht dafür ausgelegt, von mehreren Threads gleichzeitig verändert zu werden: Eine ungeschützte Verwendung kann zum Verlust von Elementen führen, unerwartete Ausnahmen auslösen oder sogar die interne Struktur der Collection beschädigen. Ab .NET 4 bietet der Namespace [System.Collections.Concurrent] Collections, die für die gemeinsame Nutzung durch Threads ohne explizites Sperren konzipiert sind:

Collection
Rolle
[ConcurrentDictionary<TKey,TValue>]
ein Dictionary, dessen Operationen, einschließlich bedingter Aktualisierungen, threadsicher sind
[ConcurrentQueue<T>]
eine Warteschlange (First-in, First-out)
[ConcurrentStack<T>]
ein Stapel (Last-in, First-out)
[ConcurrentBag<T>]
ein Bag: eine ungeordnete Collection
[BlockingCollection<T>]
ein Wrapper um die vorherigen Collections, der den Konsumenten blockiert, wenn die Collection leer ist, und gegebenenfalls den Produzenten, wenn sie voll ist

8.7.1. ConcurrentDictionary und ConcurrentQueue

Im Programm [threads-18.cs] erzeugen vier Threads Zufallszahlen und zählen in einem gemeinsamen Dictionary, wie oft jede Zahl vorkommt:

// nebenläufige Collections: ConcurrentDictionary und ConcurrentQueue

using System.Collections.Concurrent;

// das gemeinsame Dictionary: Ziffer -> Anzahl der Ziehungen
var draws = new ConcurrentDictionary<int, int>();
// die gemeinsame Warteschlange der Thread-Berichte
var reports = new ConcurrentQueue<string>();

// 4 Threads ziehen jeweils 100.000 zufällige Ziffern
const int nbDraws = 100_000;
var threads = new Thread[4];
for (int i = 0; i < threads.Length; i++)
{
    threads[i] = new Thread(() =>
    {
        for (int j = 0; j < nbDraws; j++)
        {
            int digit = Random.Shared.Next(0, 10);
            // Hinzufügen des Schlüssels mit dem Wert 1 oder atomare Aktualisierung des vorhandenen Werts
            draws.AddOrUpdate(digit, 1, (key, oldValue) => oldValue + 1);
        }
        // in die Warteschlange gelegter Bericht
        reports.Enqueue($"thread {Thread.CurrentThread.Name} has finished its {nbDraws:N0} draws");
    })
    { Name = $"T{i}" };
    threads[i].Start();
}
foreach (Thread thread in threads)
{
    thread.Join();
}

// die Berichte, in der Reihenfolge ihres Eintreffens
while (reports.TryDequeue(out string? report))
{
    Console.WriteLine(report);
}
// die Ergebnisse der Ziehungen
foreach (var (digit, count) in draws.OrderBy(pair => pair.Key))
{
    Console.WriteLine($"digit {digit}: {count,6:N0} draws");
}
Console.WriteLine($"total: {draws.Values.Sum():N0} draws (expected: {threads.Length * nbDraws:N0})");
// GetOrAdd: liefert den dem Schlüssel zugeordneten Wert, nachdem er hinzugefügt wurde, falls er nicht existierte
Console.WriteLine($"GetOrAdd(10, 0) = {draws.GetOrAdd(10, 0)}, number of keys: {draws.Count}");

Kommentare:

  • Zeile 3: der Namespace für nebenläufige Collections;
  • Zeile 6: Das gemeinsame Dictionary ordnet jeder Ziffer ihre Anzahl an Vorkommen zu;
  • Zeile 8: eine Warteschlange, in der jeder Thread am Ende seiner Arbeit einen Bericht ablegt;
  • Zeile 21: Die Methode [AddOrUpdate] fügt den Schlüssel [digit] mit dem Wert 1 hinzu, falls er nicht existiert, und ersetzt andernfalls seinen Wert durch den von der Funktion [(key, oldValue) => oldValue + 1] berechneten. Die Operation ist atomar. Wir könnten nicht [draws[digit]++] schreiben: Dieser Ausdruck liest den Wert und schreibt dann den neuen in zwei Operationen, und zwei Threads könnten eine Aktualisierung verlieren, wie im Beispiel [threads-07.cs];
  • Zeile 24: Jeder Thread legt seinen Bericht in der Warteschlange ab;
  • Zeilen 35–37: Der Hauptthread leert die Warteschlange. [TryDequeue] gibt [false] zurück, wenn die Warteschlange leer ist. Nebenläufige Collections bieten nur „Try…“-Methoden an, die Prüfung und Operation vereinen: Eine Prüfung auf [Count > 0] mit anschließendem Entfernen wäre nicht sicher, da ein anderer Thread die Warteschlange zwischenzeitlich leeren könnte;
  • Zeile 40: Das Dictionary wird in der Reihenfolge der Schlüssel durchlaufen; jedes Schlüssel-Wert-Paar wird in zwei Variablen zerlegt;
  • Zeile 46: Die Methode [GetOrAdd] gibt den dem Schlüssel zugeordneten Wert zurück, nachdem sie den Schlüssel mit dem angegebenen Wert hinzugefügt hat, falls er nicht existierte.

Ergebnisse:

> dotnet run threads-18.cs
thread T0 has finished its 100,000 draws
thread T2 has finished its 100,000 draws
thread T1 has finished its 100,000 draws
thread T3 has finished its 100,000 draws
digit 0: 40,168 draws
digit 1: 39,980 draws
digit 2: 39,982 draws
digit 3: 39,856 draws
digit 4: 40,170 draws
digit 5: 40,271 draws
digit 6: 40,081 draws
digit 7: 39,704 draws
digit 8: 39,722 draws
digit 9: 40,066 draws
total: 400,000 draws (expected: 400,000)
GetOrAdd(10, 0) = 0, number of keys: 11

Die Gesamtzahl der Ziehungen ist korrekt: Es ging keine Aktualisierung verloren. Die Berichte erscheinen in der Reihenfolge, in der die Threads ihre Arbeit abgeschlossen haben.

8.7.2. Produzenten und Konsumenten: BlockingCollection

Das Leser-Schreiber-Problem ist eine Variante des klassischen Produzenten-Konsumenten-Problems: Threads erzeugen Daten, die andere Threads verbrauchen. Die Klasse [BlockingCollection<T>] löst es ohne explizite Synchronisationswerkzeuge:

  • [Add(element)] fügt ein Element hinzu. Hat die Collection eine begrenzte Kapazität und ist sie voll, wird der Produzent blockiert, bis ein Platz frei wird;
  • [CompleteAdding()] signalisiert, dass keine weiteren Elemente hinzugefügt werden;
  • [GetConsumingEnumerable()] liefert eine Enumeration, die die Elemente nacheinander entnimmt. Ist die Collection leer, wird der Konsument blockiert, bis ein Element eintrifft; die Enumeration endet, wenn die Collection leer ist und [CompleteAdding] aufgerufen wurde.

Das Programm [threads-19.cs] lautet wie folgt:

// Producer / Consumer mit BlockingCollection<T>

using System.Collections.Concurrent;

// eine Warteschlange mit höchstens 3 Elementen
using var queue = new BlockingCollection<int>(boundedCapacity: 3);

// der Producer legt 8 Zahlen ab und signalisiert dann, dass er fertig ist
var producer = new Thread(() =>
{
    for (int i = 1; i <= 8; i++)
    {
        // blockierend, wenn die Warteschlange voll ist
        queue.Add(i);
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: P put {i} (waiting elements: {queue.Count})");
        Thread.Sleep(100);
    }
    // es werden keine Elemente mehr hinzugefügt
    queue.CompleteAdding();
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: P has finished");
});

// zwei Consumer nehmen die Zahlen, solange welche vorhanden sind
var consumers = new Thread[2];
for (int i = 0; i < consumers.Length; i++)
{
    consumers[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        // die Enumeration wartet auf die Elemente und endet, wenn die Warteschlange leer und abgeschlossen ist
        foreach (int number in queue.GetConsumingEnumerable())
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} took {number}");
            // Verarbeitung der Zahl
            Thread.Sleep(600);
        }
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} has finished");
    })
    { Name = $"C{i + 1}" };
}

// Start aller Threads und Warten auf sie
producer.Start();
foreach (Thread consumer in consumers)
{
    consumer.Start();
}
producer.Join();
foreach (Thread consumer in consumers)
{
    consumer.Join();
}

Kommentare:

  • Zeile 6: eine Warteschlange (die zugrunde liegende Standard-Collection ist eine [ConcurrentQueue<int>]), die höchstens 3 Elemente enthält. Der Parameter wird über seinen Namen übergeben, was den Aufruf lesbarer macht;
  • Zeilen 9–20: Der Produzent legt die Zahlen 1 bis 8 ab, eine alle zehntel Sekunden, und signalisiert dann, dass er fertig ist;
  • Zeilen 24–37: Zwei Konsumenten holen die Zahlen ab und benötigen jeweils 0,6 Sekunden für deren Verarbeitung. Sie verbrauchen die Zahlen langsamer, als der Produzent sie erzeugt;
  • Zeile 31: die blockierende Enumeration. Jede Zahl wird von nur einem der beiden Konsumenten abgeholt.

Ergebnisse:

> dotnet run threads-19.cs
11:37:27.216: C2 took 1
11:37:27.213: P put 1 (waiting elements: 0)
11:37:27.366: P put 2 (waiting elements: 1)
11:37:27.366: C1 took 2
11:37:27.466: P put 3 (waiting elements: 1)
11:37:27.566: P put 4 (waiting elements: 2)
11:37:27.666: P put 5 (waiting elements: 3)
11:37:27.866: C2 took 3
11:37:27.866: P put 6 (waiting elements: 3)
11:37:27.966: C1 took 4
11:37:27.966: P put 7 (waiting elements: 3)
11:37:28.466: C2 took 5
11:37:28.466: P put 8 (waiting elements: 3)
11:37:28.566: C1 took 6
11:37:28.567: P has finished
11:37:29.066: C2 took 7
11:37:29.167: C1 took 8
11:37:29.667: C2 has finished
11:37:29.767: C1 has finished

Wir sehen, dass der Produzent die ersten Zahlen schnell einreiht und dann – sobald die Warteschlange 3 Elemente enthält – nur noch eine Zahl einreiht, wenn ein Konsument eine entnimmt: Er wird bei [Add] blockiert, wenn die Warteschlange voll ist. Die Konsumenten teilen sich die Zahlen und halten an, wenn die Warteschlange leer und der Vorgang abgeschlossen ist. Beachten Sie, dass der Konsument C2 die Entnahme der Zahl 1 anzeigte, bevor der Produzent ihr Einfügen anzeigte: Das Einfügen fand tatsächlich früher statt, aber der Produzent wurde zwischen [Add] und seiner Anzeige unterbrochen.

Die Klasse [Channel<T>] im Namespace [System.Threading.Channels] bietet denselben Dienst für die asynchrone Programmierung: Ein Konsument, der auf ein Element wartet, blockiert keine Threads. Wir behandeln dies im nächsten Kapitel.

8.8. Der Thread-Pool

Bisher haben wir Threads verwaltet, indem wir sie mit [new Thread(...)] erzeugt und dann mit [Start()] ausgeführt haben. Das Erzeugen eines Threads ist eine relativ aufwendige Operation: Insbesondere muss das System dafür einen Stack reservieren, und jeder Thread belegt Speicher, solange er existiert. Im Kapitel über Datenbanken werden wir sehen, dass es Verbindungspools gibt: Geöffnete Verbindungen werden in Reserve gehalten und an Threads verliehen, die sie anfordern, da das Öffnen einer Verbindung aufwendig ist. Ein ähnliches System gibt es für Threads: den Thread-Pool (ThreadPool) von .NET.

  • Solange die Anzahl der Threads im Pool unter einem Mindestwert liegt, erzeugt der Pool sofort einen neuen Thread für jede Aufgabe, die keinen freien Thread findet. Standardmäßig entspricht dieser Mindestwert der Anzahl der Prozessoren; er kann mit [ThreadPool.GetMinThreads(out min1, out min2)] gelesen und mit [ThreadPool.SetMinThreads(min1, min2)] geändert werden. Der Pool verwaltet zwei Arten von Threads: Worker-Threads (min1), die die ihnen zugewiesenen Jobs ausführen, und asynchrone E/A-Threads (min2);
  • reicht diese Anzahl nicht aus, erzeugt der Pool schrittweise zusätzliche Threads, bis zu einem Höchstwert, der mit [ThreadPool.GetMaxThreads(out max1, out max2)] gelesen und mit [ThreadPool.SetMaxThreads(max1, max2)] geändert werden kann. Ist das Maximum erreicht, werden die dem Pool zugewiesenen Jobs in eine Warteschlange gestellt, bis ein Thread verfügbar wird;
  • Ein Thread, der eine Aufgabe abgeschlossen hat, wird nicht zerstört: Er wird an den Pool zurückgegeben und für die nächste Aufgabe verwendet.

Der Thread-Pool bietet zwei Vorteile: Er spart die Zeit, die für das Erzeugen von Threads aufgewendet würde (einige wenige Threads können Hunderte von Anfragen bearbeiten), und indem er die Anzahl der Threads begrenzt, verhindert er, dass die Anwendung durch zu viele Anfragen überlastet wird.

Um dem Pool eine Aufgabe zuzuweisen, verwenden Sie die Methode [ThreadPool.QueueUserWorkItem(WaitCallback callback, object? state)], wobei [WaitCallback] ein Delegat mit der Signatur [void M(object? state)] ist. Die Aufgabe wird von einem Thread des Pools mit dem Parameter [state] ausgeführt. Das Programm [threads-20.cs] lautet wie folgt:

// der Thread-Pool

// der Hauptthread
Thread.CurrentThread.Name = "Main";

// minimale Anzahl der Threads im Pool
ThreadPool.GetMinThreads(out int min1, out int min2);
Console.WriteLine($"Minimum number of worker threads in the pool: {min1}");
Console.WriteLine($"Minimum number of asynchronous I/O threads in the pool: {min2}");
ThreadPool.SetMinThreads(3, min2);
ThreadPool.GetMinThreads(out min1, out _);
Console.WriteLine($"Minimum number of worker threads after change: {min1}");
// maximale Anzahl der Threads im Pool
ThreadPool.GetMaxThreads(out int max1, out int max2);
Console.WriteLine($"Maximum number of worker threads in the pool: {max1}");
Console.WriteLine($"Maximum number of asynchronous I/O threads in the pool: {max2}");
bool ok = ThreadPool.SetMaxThreads(5, max2);
ThreadPool.GetMaxThreads(out max1, out _);
Console.WriteLine($"Maximum number of worker threads after change: {max1} (SetMaxThreads returned {ok})");

// wir übergeben 7 Aufträge an den Pool; der Countdown lässt uns auf ihr Ende warten
using var remainingJobs = new CountdownEvent(7);
for (int i = 0; i < 7; i++)
{
    var data = new Data { Number = i, Start = DateTime.Now, Duration = 3 };
    ThreadPool.QueueUserWorkItem(Sleep, data);
}
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, the Main thread has handed the 7 jobs to the pool and waits for their end");
// Warten auf das Ende der 7 Aufträge
remainingJobs.Wait();
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, end of the Main thread");

// der von einem Pool-Thread ausgeführte Auftrag
void Sleep(object? state)
{
    if (state is not Data data)
    {
        return;
    }
    // Zustand des Pools
    ThreadPool.GetAvailableThreads(out int available, out _);
    Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, job no. {data.Number} starts in thread {Thread.CurrentThread.ManagedThreadId} for {data.Duration} s (available worker threads: {available})");
    // Duration Sekunden schlafen
    Thread.Sleep(data.Duration * 1000);
    DateTime end = DateTime.Now;
    Console.WriteLine($"At {end:HH:mm:ss.ff}, job no. {data.Number} ends: scheduled for {data.Duration} s, it lasted {(end - data.Start).TotalSeconds:F2} s since its request");
    // ein Auftrag weniger
    remainingJobs.Signal();
}

// die an jeden Auftrag übergebene Information
class Data
{
    public int Number { get; init; }
    public DateTime Start { get; init; }
    public int Duration { get; init; }
}

Kommentare:

  • Zeilen 7–12: Wir lesen und zeigen die aktuelle Mindestanzahl beider Thread-Arten im Pool an und setzen dann die Mindestanzahl der Worker-Threads auf 3. Der Parameter [out _] ist ein „verworfener Parameter“: Der zurückgegebene Wert interessiert uns nicht;
  • Zeilen 14–19: Wir gehen genauso vor, um die Höchstanzahl der Worker-Threads auf 5 zu setzen. [SetMaxThreads] gibt [false] zurück, wenn der angeforderte Wert abgelehnt wird, zum Beispiel wenn er kleiner als die Anzahl der Prozessoren ist;
  • Zeile 22: Ein Objekt [CountdownEvent] fungiert als Countdown-Zähler: Jeder Aufruf seiner Methode [Signal] verringert ihn, und seine Methode [Wait] blockiert den aufrufenden Thread, bis er 0 erreicht. Hier ermöglicht er dem Hauptthread, auf das Ende der 7 Jobs zu warten: Sie können [Join] nicht für einen Thread aus dem Pool aufrufen, da er Ihnen nicht gehört. Im Kurs von 2008 wurde der Benutzer aufgefordert, nach Abschluss der Jobs [Enter] zu drücken;
  • Zeilen 23–26: Wir weisen dem Pool 7 Aufgaben von jeweils 3 Sekunden Dauer zu, obwohl der Pool nie mehr als 5 Worker-Threads haben wird. Jede Aufgabe erhält ein Objekt [Data];
  • Zeile 30: Der Hauptthread wartet auf das Ende der 7 Jobs;
  • Zeilen 34–48: die Aufgabe, die von einem Thread im Pool ausgeführt wird. Dies ist eine nicht statische lokale Funktion, da sie die lokale Variable [remainingJobs] verwendet;
  • Zeile 41: die Anzahl der noch verfügbaren Worker-Threads (das Maximum abzüglich der Anzahl ausgelasteter Threads);
  • Zeile 48: Der Zähler wird am Ende jedes Jobs verringert.

Ergebnisse:

> dotnet run threads-20.cs
Minimum number of worker threads in the pool: 2
Minimum number of asynchronous I/O threads in the pool: 1
Minimum number of worker threads after change: 3
Maximum number of worker threads in the pool: 32767
Maximum number of asynchronous I/O threads in the pool: 1000
Maximum number of worker threads after change: 5 (SetMaxThreads returned True)
At 11:37:31.85, the Main thread has handed the 7 jobs to the pool and waits for their end
At 11:37:31.85, job no. 1 starts in thread 6 for 3 s (available worker threads: 2)
At 11:37:31.85, job no. 0 starts in thread 4 for 3 s (available worker threads: 2)
At 11:37:31.85, job no. 2 starts in thread 7 for 3 s (available worker threads: 2)
At 11:37:32.85, job no. 3 starts in thread 8 for 3 s (available worker threads: 1)
At 11:37:33.85, job no. 4 starts in thread 9 for 3 s (available worker threads: 0)
At 11:37:34.85, job no. 0 ends: scheduled for 3 s, it lasted 3.04 s since its request
At 11:37:34.85, job no. 1 ends: scheduled for 3 s, it lasted 3.00 s since its request
At 11:37:34.85, job no. 2 ends: scheduled for 3 s, it lasted 3.00 s since its request
At 11:37:34.85, job no. 5 starts in thread 7 for 3 s (available worker threads: 0)
At 11:37:34.85, job no. 6 starts in thread 4 for 3 s (available worker threads: 0)
At 11:37:35.85, job no. 3 ends: scheduled for 3 s, it lasted 4.00 s since its request
At 11:37:36.85, job no. 4 ends: scheduled for 3 s, it lasted 5.00 s since its request
At 11:37:37.85, job no. 6 ends: scheduled for 3 s, it lasted 6.00 s since its request
At 11:37:37.85, job no. 5 ends: scheduled for 3 s, it lasted 6.00 s since its request
At 11:37:37.85, end of the Main thread
  • Auf diesem Rechner mit zwei Prozessoren hatte der Pool anfangs mindestens 2 Worker-Threads und höchstens 32.767;
  • die Jobs 0, 1 und 2 starteten sofort: Der Pool hat mindestens 3 Threads;
  • die Jobs 3 und 4 starteten mit einer Verzögerung von einer bzw. zwei Sekunden: Es waren keine freien Threads mehr vorhanden, und der Pool erzeugt – sobald er sein Minimum überschreitet – nur schrittweise neue Threads, solange Jobs warten. Das Maximum von 5 Threads ist dann erreicht: Es bleiben keine Threads verfügbar;
  • Die Jobs 5 und 6 mussten warten, bis nach Abschluss der Jobs 0, 1 und 2 ein Thread verfügbar wurde. Wir sehen, dass sie die Threads 7 und 4 wiederverwendeten, die die ersten Jobs ausgeführt hatten;
  • Insgesamt benötigten die Jobs 5 und 6 ab ihrer Anforderung 6 Sekunden: 3 Sekunden Wartezeit und 3 Sekunden Ausführung.

Es ist selten nötig, die Grenzen des Pools zu ändern: Seine Standardwerte eignen sich für die meisten Anwendungen. Tatsächlich wird [QueueUserWorkItem] selten direkt verwendet: Man arbeitet mit Tasks, die weiter unten beschrieben werden.

8.9. Tasks und die Parallel Library

8.9.1. Task.Run

Seit .NET 4 stellt die Klasse [System.Threading.Tasks.Task] einen Job (einen Task) dar, der asynchron ausgeführt wird. [Task.Run(action)] weist dem Thread-Pool einen Job zu, genau wie [QueueUserWorkItem], gibt aber ein Objekt [Task] zurück, mit dem Sie diesen Job verfolgen können: Sie können prüfen, ob er beendet ist, auf ihn warten, sein Ergebnis abrufen oder die Ausnahme, die er ausgelöst hat. Ein Task, der ein Ergebnis vom Typ T zurückgibt, hat den Typ [Task<T>]. Das Programm [threads-21.cs] lautet wie folgt:

// Task.Run: einen Auftrag an den Thread-Pool übergeben und sein Ergebnis erhalten

Console.WriteLine($"Main thread: id {Thread.CurrentThread.ManagedThreadId}, pool thread: {Thread.CurrentThread.IsThreadPoolThread}");

// drei Tasks, die jeweils ein Ergebnis vom Typ int zurückgeben
var tasks = new Task<int>[3];
for (int i = 0; i < tasks.Length; i++)
{
    int number = i;
    tasks[i] = Task.Run(() =>
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: task {number} runs in thread {Thread.CurrentThread.ManagedThreadId} (pool thread: {Thread.CurrentThread.IsThreadPoolThread})");
        // Arbeit
        Thread.Sleep(500 * (number + 1));
        // das Ergebnis des Tasks
        return number * 10;
    });
}
// Warten auf das Ende der drei Tasks (blockierend)
Task.WaitAll(tasks);
// die Ergebnisse
for (int i = 0; i < tasks.Length; i++)
{
    Console.WriteLine($"task {i}: status {tasks[i].Status}, result {tasks[i].Result}");
}

// ein Task, der eine Exception auslöst
Task failingTask = Task.Run(Fail);
try
{
    // die Exception des Tasks wird von Wait erneut ausgelöst, verpackt in eine AggregateException
    failingTask.Wait();
}
catch (AggregateException e)
{
    Console.WriteLine($"{e.GetType().Name} containing {e.InnerException?.GetType().Name}: {e.InnerException?.Message}");
}
Console.WriteLine($"failed task: status {failingTask.Status}");

// die Arbeit des fehlschlagenden Tasks
static void Fail() => throw new InvalidOperationException("test....");

Kommentare:

  • Zeilen 10–16: Jeder Task führt ein Lambda aus, das den ausführenden Thread anzeigt, 0,5, 1 oder 1,5 Sekunden pausiert und dann ein Ergebnis vom Typ [int] zurückgibt. [Task.Run] gibt daher einen [Task<int>] zurück;
  • Zeile 20: Der Hauptthread wartet auf das Ende der drei Tasks. Dies ist ein blockierendes Warten, wie bei [Join];
  • Zeile 24: Die Eigenschaft [Status] gibt den Zustand des Tasks an; [RanToCompletion] bedeutet, dass er normal abgeschlossen wurde;
  • Zeile 24: Die Eigenschaft [Result] ist das Ergebnis des Tasks. Wäre der Task nicht abgeschlossen, würde das Lesen von [Result] den Thread blockieren, bis er beendet ist;
  • Zeile 28: ein Task, der die Methode [Fail] ausführt, die eine Ausnahme auslöst;
  • Zeile 32: Die im Task ausgelöste Ausnahme geht nicht verloren: Sie wird im Objekt [Task] gespeichert, dann im Thread, der auf den Task wartet, erneut ausgelöst. [Wait] verpackt sie in eine [AggregateException] (ein Task kann mehrere davon bündeln), deren Eigenschaft [InnerException] die ursprüngliche Ausnahme ist;
  • Zeile 41: die Methode, die die Ausnahme auslöst. Wir hätten das Lambda [() => throw new InvalidOperationException(...)] auch direkt an [Task.Run] übergeben können.

Ergebnisse:

> dotnet run threads-21.cs
Main thread: id 1, pool thread: False
11:37:39.970: task 0 runs in thread 4 (pool thread: True)
11:37:39.969: task 1 runs in thread 6 (pool thread: True)
11:37:40.516: task 2 runs in thread 4 (pool thread: True)
task 0: status RanToCompletion, result 0
task 1: status RanToCompletion, result 10
task 2: status RanToCompletion, result 20
AggregateException containing InvalidOperationException: test....
failed task: status Faulted
  • Die Tasks laufen in Threads aus dem Pool (Zeile 3);
  • Task 2 startete erst, nachdem Task 0 beendet war, und zwar in dem Thread, den Task 0 freigegeben hatte: Der Pool hatte nur 2 Threads (das Standardminimum auf diesem Rechner) und erzeugte nicht rechtzeitig einen dritten;
  • die Ergebnisse werden nach Abschluss der Tasks abgerufen;
  • die Ausnahme des fehlgeschlagenen Tasks wurde vom Hauptthread abgefangen, und der Zustand des Tasks ist [Faulted].

Dieses Beispiel ersetzt auch dasjenige zur Klasse [BackgroundWorker] aus dem Kurs von 2008, das zeigte, wie man einen Job im Hintergrund ausführt, sein Ergebnis oder seine Ausnahme abruft und ihn abbricht. [BackgroundWorker] wurde für grafische Windows-Forms-Benutzeroberflächen entwickelt; er wurde inzwischen durch Tasks ersetzt, wobei der Abbruch über [CancellationToken] und die Fortschrittsverfolgung über die Schnittstelle [IProgress<T>] erfolgt. Beide werden im folgenden Kapitel zusammen mit [async] / [await] vorgestellt, die es erlauben, auf einen Task zu warten, ohne einen Thread zu blockieren.

8.9.2. Parallel.For und Parallel.ForEach

Die Klasse [System.Threading.Tasks.Parallel] (.NET 4) verteilt die Iterationen einer Schleife automatisch auf mehrere Threads des Pools:

  • [Parallel.For(start, end, i => ...)] führt den Schleifenrumpf für i von [start] bis [end] - 1 aus;
  • [Parallel.ForEach(collection, element => ...)] führt den Schleifenrumpf für jedes Element der Collection aus;
  • ein Parameter [ParallelOptions] erlaubt es, die Anzahl gleichzeitig ausgeführter Iterationen zu begrenzen (Eigenschaft [MaxDegreeOfParallelism]);
  • beide Methoden geben die Kontrolle erst zurück, wenn alle Iterationen abgeschlossen sind. Der Thread, der sie aufruft, beteiligt sich selbst an der Arbeit.

Diese Schleifen eignen sich nur, wenn die Iterationen unabhängig voneinander sind: Ihre Ausführungsreihenfolge ist undefiniert, und wenn sie gemeinsame Daten aktualisieren, müssen diese Daten geschützt werden. Das Programm [threads-22.cs] lautet wie folgt:

// die Parallelbibliothek: Parallel.For und Parallel.ForEach

using System.Collections.Concurrent;
using System.Diagnostics;

// 1 - die Primzahlen unterhalb von N zählen
const int N = 5_000_000;
// sequenzielle Version
var stopwatch = Stopwatch.StartNew();
int nbSequential = 0;
for (int i = 2; i < N; i++)
{
    if (IsPrime(i))
    {
        nbSequential++;
    }
}
Console.WriteLine($"sequential for    : {nbSequential:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");

// parallele Version Nr. 1: die Iterationen werden auf mehrere Threads verteilt
stopwatch.Restart();
int nbParallel1 = 0;
Parallel.For(2, N, i =>
{
    if (IsPrime(i))
    {
        // der Zähler wird gemeinsam genutzt: atomares Inkrementieren
        Interlocked.Increment(ref nbParallel1);
    }
});
Console.WriteLine($"Parallel.For no. 1: {nbParallel1:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");

// parallele Version Nr. 2: jeder Thread zählt in einer lokalen Variablen,
// die nur ein einziges Mal, am Ende, zur gemeinsamen Summe addiert wird
stopwatch.Restart();
int nbParallel2 = 0;
// die Threads, die gearbeitet haben, und die Anzahl der von jedem gefundenen Primzahlen
var threads = new ConcurrentDictionary<int, int>();
Parallel.For(2, N,
    // Initialisierung des lokalen Zählers
    () => 0,
    // der Schleifenrumpf gibt den neuen Wert des lokalen Zählers zurück
    (i, state, local) => IsPrime(i) ? local + 1 : local,
    // Ende der Arbeit eines Threads: wir addieren seinen lokalen Zähler zur Summe
    local =>
    {
        Interlocked.Add(ref nbParallel2, local);
        threads.AddOrUpdate(Environment.CurrentManagedThreadId, local, (_, n) => n + local);
    });
Console.WriteLine($"Parallel.For no. 2: {nbParallel2:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");
foreach (var (id, nb) in threads.OrderBy(pair => pair.Key))
{
    Console.WriteLine($"  thread {id}: {nb:N0} prime numbers found");
}

// 2 - eine Collection mit höchstens 2 gleichzeitigen Verarbeitungen verarbeiten
string[] files = ["a.txt", "b.txt", "c.txt", "d.txt", "e.txt"];
var options = new ParallelOptions { MaxDegreeOfParallelism = 2 };
Parallel.ForEach(files, options, file =>
{
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: processing of {file} in thread {Environment.CurrentManagedThreadId}");
    // simulierte Verarbeitung
    Thread.Sleep(500);
});
Console.WriteLine("Parallel.ForEach finished");

// Primzahltest (bewusst einfach)
static bool IsPrime(int n)
{
    if (n < 2)
    {
        return false;
    }
    for (int d = 2; d * d <= n; d++)
    {
        if (n % d == 0)
        {
            return false;
        }
    }
    return true;
}

Kommentare:

  • Zeilen 7–18: Wir zählen die Primzahlen unter 5.000.000 mit einer gewöhnlichen [for]-Schleife. Die Funktion [IsPrime] (Zeilen 68–81) testet Teiler bis zur Quadratwurzel der Zahl: Das ist zeitaufwendig, und die Iterationen sind voneinander unabhängig;
  • Zeilen 22–31: dieselbe Schleife mit [Parallel.For]. Der Zähler [nbParallel1] wird von allen Threads gemeinsam genutzt: Er wird mit [Interlocked.Increment] erhöht (eine lokale Variable, die von einem Lambda erfasst wird, kann als Referenz übergeben werden);
  • Zeilen 36–50: Eine überladene Version von [Parallel.For] erlaubt die Arbeit mit einer lokalen Variablen: [Parallel.For] zerlegt die Schleife in Tasks, die jeweils von einem einzigen Thread ausgeführt werden, und jeder Task hat seinen eigenen Zähler. Das erste Lambda (41) initialisiert den Zähler eines Tasks; das zweite (43) ist der Schleifenrumpf, der den Zähler entgegennimmt und seinen neuen Wert zurückgibt; das dritte (45) wird einmal pro Task am Ende seiner Arbeit ausgeführt: Es addiert den Zähler des Tasks zur gemeinsamen Summe. Dadurch verringert sich die Anzahl atomarer Operationen erheblich;
  • Zeile 48: Für jeden beteiligten Thread halten wir die Anzahl der Primzahlen fest, die er gefunden hat;
  • Zeilen 57–65: [Parallel.ForEach] verarbeitet eine Sammlung von Dateinamen (die Verarbeitung wird durch eine halbe Sekunde Pause simuliert), mit höchstens 2 gleichzeitigen Verarbeitungen.

Ergebnisse:

> dotnet run threads-22.cs
sequential for    : 348,513 prime numbers in 2061 ms
Parallel.For no. 1: 348,513 prime numbers in 2161 ms
Parallel.For no. 2: 348,513 prime numbers in 1928 ms
  thread 1: 112,640 prime numbers found
  thread 4: 118,169 prime numbers found
  thread 5: 36,754 prime numbers found
  thread 7: 80,950 prime numbers found
11:37:50.239: processing of c.txt in thread 7
11:37:50.239: processing of a.txt in thread 1
11:37:50.776: processing of d.txt in thread 7
11:37:50.776: processing of b.txt in thread 1
11:37:51.277: processing of e.txt in thread 7
Parallel.ForEach finished
  • Alle drei Schleifen finden dieselbe Anzahl an Primzahlen;
  • mehrere Threads beteiligten sich an der parallelen Schleife, darunter der Hauptthread (ID 1);
  • die Verarbeitung von [Parallel.ForEach] erfolgt paarweise im Abstand einer halben Sekunde und in einer Reihenfolge, die nicht der der Liste entspricht;
  • Die Zeitersparnis ist bei diesem Lauf enttäuschend: Es gibt nur 2 Prozessoren, die sich die Threads unseres Programms zum Zeitpunkt der Aufnahme mit anderen, sehr aktiven Programmen teilen mussten. Auf einem wenig ausgelasteten Rechner mit n Prozessoren kann eine parallele Schleife wie diese fast n-mal schneller sein als die sequenzielle Schleife. Sie sollten immer messen, bevor Sie Schlüsse ziehen: Die Parallelisierung hat Kosten (Arbeitsverteilung, Synchronisation), die sich nur lohnen, wenn jede Iteration genügend Rechenaufwand erfordert.

8.10. Threadlokale Daten

8.10.1. Das Prinzip

Betrachten wir eine Anwendung mit drei Schichten:

Image

Angenommen, die Anwendung ist mehrbenutzerfähig, etwa eine Webanwendung. Jede Benutzeranfrage wird von einem Thread bearbeitet. Der Lebenszyklus des Threads sieht wie folgt aus:

  • Der Thread wird erzeugt oder aus dem Thread-Pool geholt, um die Anfrage eines Benutzers zu erfüllen;
  • wenn diese Anfrage Daten benötigt, führt der Thread eine Methode der Schicht [ui] aus, die eine Methode der Schicht [business] aufruft, die ihrerseits eine Methode der Schicht [dao] aufruft;
  • der Thread gibt die Antwort an den Benutzer zurück. Danach wird er entweder beendet oder an den Thread-Pool zurückgegeben.

Im zweiten Schritt kann es nützlich sein, dass der Thread über eigene Daten verfügt – also über Daten, die nicht mit anderen Threads geteilt werden. Diese Daten könnten beispielsweise dem konkreten Benutzer gehören, den der Thread bedient, und in den verschiedenen Schichten [ui, business, dao] verwendet werden, ohne dass sie jeder Methode als Parameter übergeben werden.

Im Kurs von 2008 wurden dafür die Methoden [Thread.SetData] und [Thread.GetData] verwendet, die eine Art privates Dictionary des Threads verwalten. Sie existieren noch, werden aber selten benutzt; zwei einfachere und effizientere Werkzeuge werden bevorzugt:

  • das Attribut [[ThreadStatic]] auf einem statischen Feld: Jeder Thread hat seine eigene Instanz des Feldes;
  • die Klasse [ThreadLocal<T>]: ein Objekt, dessen Eigenschaft [Value] für jeden Thread einen anderen Wert hat. Eine an den Konstruktor übergebene Funktion liefert den Anfangswert für jeden Thread.

Das Programm [threads-23.cs] vergleicht ein gewöhnliches statisches Feld mit diesen beiden Werkzeugen:

// threadlokale Daten: [ThreadStatic] und ThreadLocal<T>

Thread.CurrentThread.Name = "Main";
// der Hauptthread schreibt seine eigenen Werte
Context.Shared = 100;
Context.PerThread = 100;
Context.User.Value = "admin";

// drei Threads schreiben und lesen dann die drei Daten erneut
var threads = new Thread[3];
for (int i = 0; i < threads.Length; i++)
{
    int number = i;
    threads[i] = new Thread(() =>
    {
        // Schreiben
        Context.Shared = number;
        Context.PerThread = number;
        // Thread T2 setzt keinen Benutzer: er erhält den Standardwert
        if (number != 2)
        {
            Context.User.Value = $"user{number}";
        }
        // wir lassen die anderen Threads der Reihe nach schreiben
        Thread.Sleep(200);
        // erneutes Lesen
        Display();
    })
    { Name = $"T{i}" };
    threads[i].Start();
}
foreach (Thread thread in threads)
{
    thread.Join();
}
// erneutes Lesen durch den Hauptthread
Display();

// zeigt die vom aktuellen Thread gesehenen Daten an
static void Display()
{
    Console.WriteLine($"{Thread.CurrentThread.Name,-4} : Shared={Context.Shared,-3} PerThread={Context.PerThread,-3} WithInitializer={Context.WithInitializer,-2} User={Context.User.Value}");
}

// die Daten des Programms
static class Context
{
    // ein gewöhnliches statisches Feld: eine einzige Kopie, von allen Threads gemeinsam genutzt
    public static int Shared;
    // eine Kopie pro Thread
    [ThreadStatic]
    public static int PerThread;
    // Falle: der Initialisierer wird nur für den ersten Thread ausgeführt, der die Klasse verwendet
    [ThreadStatic]
    public static int WithInitializer = 5;
    // eine Kopie pro Thread, für jeden Thread von der dem Konstruktor übergebenen Factory initialisiert
    public static readonly ThreadLocal<string> User = new(() => $"anonymous (thread {Thread.CurrentThread.Name})");
}

Kommentare:

  • Zeile 49: ein gewöhnliches statisches Feld. Es gibt davon nur eine Instanz, die von allen Threads gemeinsam genutzt wird;
  • Zeilen 51–52: Das Attribut [[ThreadStatic]] gibt jedem Thread eine Instanz des Feldes;
  • Zeilen 54–55: eine klassische Falle. Der Initialisierer [= 5] wird vom statischen Konstruktor der Klasse nur ein einziges Mal ausgeführt, und zwar in dem Thread, der die Klasse als Erster verwendet. Für die anderen Threads hat das Feld den Standardwert seines Typs, hier also 0;
  • Zeile 57: ein Objekt [ThreadLocal<string>]. Das an den Konstruktor übergebene Lambda wird beim ersten Lesen von [Value] durch einen Thread ausgeführt, der noch nicht darauf geschrieben hat; es liefert den Anfangswert für diesen Thread;
  • Zeilen 5–7: Der Hauptthread schreibt seine eigenen Werte;
  • Zeilen 17–22: Jeder Thread schreibt seine eigenen Werte, mit Ausnahme des Threads T2, der keinen Benutzer setzt;
  • Zeile 25: Jeder Thread wartet darauf, dass die anderen geschrieben haben, bevor er die Werte erneut liest.

Ergebnisse:

1
2
3
4
5
> dotnet run threads-23.cs
T0   : Shared=2   PerThread=0   WithInitializer=0  User=user0
T2   : Shared=2   PerThread=2   WithInitializer=0  User=anonymous (thread T2)
T1   : Shared=2   PerThread=1   WithInitializer=0  User=user1
Main : Shared=2   PerThread=100 WithInitializer=5  User=admin
  • das gewöhnliche Feld [Shared] hat für alle Threads denselben Wert: den zuletzt geschriebenen (bei dieser Ausführung den des Threads T2);
  • das Feld [PerThread] behielt in jedem Thread den Wert, den dieser Thread hineingeschrieben hatte;
  • das Feld [WithInitializer] ist für den Hauptthread 5 und für die anderen 0;
  • die Eigenschaft [User.Value] hat den Wert, den jeder Thread geschrieben hat; der Thread T2, der nicht darauf geschrieben hatte, erhielt den vom Lambda des Konstruktors gelieferten Anfangswert.

Threadlokale Daten haben eine Einschränkung: Sie gelten für den Thread, nicht für den Prozess. Bei der asynchronen Programmierung, die im nächsten Kapitel behandelt wird, kann ein einzelner Vorgang in einem Thread beginnen und nach einem Warten in einem anderen fortgesetzt werden. In diesem Fall verwenden wir die Klasse [AsyncLocal<T>], deren Wert über Threads hinweg erhalten bleibt.

8.10.2. Anwendung: Eine über mehrere Schichten geteilte Transaktion

Betrachten Sie die folgende Anwendung mit drei Schichten, in der die Schicht [dao] eine Tabelle mit Artikeln verwaltet:

Image

Angenommen, die Schnittstelle der Schicht [dao] sieht zunächst wie folgt aus:

1
2
3
4
5
6
interface IDao
{
    int InsertArticle(Article article);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

Später entsteht die Anforderung, ein Array von Artikeln innerhalb einer Transaktion einzufügen, weil das System nach dem Alles-oder-nichts-Prinzip arbeiten muss: Entweder werden alle Artikel eingefügt oder keiner. Eine Methode namens [InsertArticles(Article[] articles)] kann der Schnittstelle hinzugefügt werden. Dann entsteht für eine andere Anwendung die Anforderung, eine Liste von Artikeln zu löschen, wiederum innerhalb einer Transaktion … Um unterschiedliche fachliche Anforderungen zu erfüllen, wird die Schicht [dao] wachsen. Wir können einen anderen Ansatz wählen:

  • nur die grundlegenden Operationen (Einfügen, Ändern, Löschen, Lesen eines Artikels) in die Schicht [dao] aufnehmen;
  • Operationen, die mehrere Artikel gleichzeitig aktualisieren, in die Schicht [business] verlagern. Diese Operationen verwenden die grundlegenden Operationen der Schicht [dao].

Der Vorteil dieser Lösung besteht darin, dass dieselbe Schicht [dao] unverändert mit verschiedenen Schichten [business] verwendet werden kann. Sie bringt eine Herausforderung bei der Verwaltung der Transaktion mit sich, die die atomar auszuführenden Aktualisierungen zusammenfasst:

  • Die Transaktion muss von der Schicht [business] gestartet werden, bevor sie die Methoden der Schicht [dao] aufruft;
  • die Methoden der Schicht [dao] müssen von der Existenz der Transaktion wissen, um daran teilnehmen zu können;
  • die Transaktion muss von der Schicht [business] abgeschlossen werden (Commit oder Rollback).

Damit die Methoden der Schicht [dao] von einer laufenden Transaktion wissen, könnte die Transaktion als Parameter zu jeder Methode der Schicht [dao] hinzugefügt werden. Dieser Parameter würde dann in der Signatur der Schnittstellenmethoden erscheinen, was die Schnittstelle an eine bestimmte Datenquelle binden würde. Threadlokale Daten bieten eine elegantere Lösung: Die Schicht [business] legt die Transaktion in den threadlokalen Daten ab, und dort ruft die Schicht [dao] sie ab. Die Methodensignaturen der Schicht [dao] müssen nicht geändert werden. Mehrere Threads (mehrere Benutzer) können gleichzeitig arbeiten: Jeder hat seine eigene Transaktion.

Im Kurs von 2008 wurde eine SQL-Server-Compact-Datenbank verwendet, ein Produkt, das inzwischen eingestellt wurde. Datenbanken werden in den Kapiteln zu ADO.NET und Entity Framework Core behandelt. Um den Fokus auf Threads zu halten, verwenden wir hier eine Tabelle im Arbeitsspeicher und eine simulierte Transaktion. Das Programm [threads-24.cs] vereint alle Schichten in einer einzigen Datei. Die Entitäten lauten wie folgt:

// ein Artikel
record Article(int Id, string Name, decimal Price, int CurrentStock, int MinimumStock);

// eine simulierte Transaktion: sie merkt sich, wie jede Aktualisierung rückgängig zu machen ist
class Transaction
{
    private static int counter;
    private readonly Stack<Action> undos = new();
    public int Number { get; } = Interlocked.Increment(ref counter);

    // merkt sich die Operation, die eine Aktualisierung rückgängig macht
    public void Log(Action undo) => undos.Push(undo);
    // bestätigt die Transaktion: die Aktualisierungen bleiben erhalten
    public void Commit() => undos.Clear();
    // macht die Transaktion rückgängig: die Aktualisierungen werden vom letzten bis zum ersten zurückgenommen
    public void Rollback()
    {
        while (undos.TryPop(out Action? undo))
        {
            undo();
        }
    }
}

// die threadlokalen Daten, die von den Schichten gemeinsam genutzt werden
static class ThreadContext
{
    // die aktuelle Transaktion des Threads (null, falls keine vorhanden ist)
    public static readonly ThreadLocal<Transaction?> Transaction = new();
}
  • Zeile 60: Ein Artikel ist ein [record] , dessen Bezeichner [Id] von der Schicht [dao] vergeben wird;
  • Zeilen 63–78: eine simulierte Transaktion. Jede innerhalb der Transaktion vorgenommene Aktualisierung hält die zu ihrem Rückgängigmachen nötige Operation fest (Methode [Log]); [Commit] bestätigt die Transaktion und ignoriert diese Operationen; [Rollback] macht sie rückgängig, indem es die Rollback-Operationen von der letzten bis zur ersten ausführt (daher der Stack [Stack<Action>]). Eine echte Datenbank arbeitet ähnlich mit einem Transaktionsprotokoll;
  • Zeile 67: Jeder Transaktion wird eine eindeutige Nummer zugewiesen. Da Transaktionen von mehreren Threads gleichzeitig erzeugt werden können, wird der Zähler atomar erhöht;
  • Zeilen 84–87: die threadlokalen Daten, die von den Schichten gemeinsam genutzt werden: die aktuelle Transaktion des Threads oder [null] , falls es keine gibt.

Die Schicht [dao] sieht wie folgt aus:

// die [dao]-Schicht: eine speicherinterne Artikeltabelle mit einer Eindeutigkeitsbedingung auf dem Namen
interface IDao
{
    int InsertArticle(Article article);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

class Dao : IDao
{
    // die Tabelle, die von allen Threads gemeinsam genutzt wird, und ihre Sperre
    private readonly List<Article> table = [];
    private readonly Lock padlock = new();
    private int nextId = 1;

    public int InsertArticle(Article article)
    {
        // läuft im aktuellen Thread eine Transaktion?
        Transaction? transaction = ThreadContext.Transaction.Value;
        lock (padlock)
        {
            if (table.Any(a => a.Name == article.Name))
            {
                throw new InvalidOperationException($"an article named [{article.Name}] already exists");
            }
            Article inserted = article with { Id = nextId++ };
            table.Add(inserted);
            // innerhalb einer Transaktion merken wir uns, wie das Einfügen rückgängig gemacht wird
            transaction?.Log(() =>
            {
                lock (padlock)
                {
                    table.Remove(inserted);
                }
            });
            string mode = transaction is null ? "outside a transaction" : $"in transaction {transaction.Number}";
            Console.WriteLine($"[{Thread.CurrentThread.Name}] [dao] insertion of {inserted.Name} (id {inserted.Id}) {mode}");
            return 1;
        }
    }

    public List<Article> GetAllArticles()
    {
        lock (padlock)
        {
            return [.. table];
        }
    }

    public void DeleteAllArticles()
    {
        lock (padlock)
        {
            table.Clear();
        }
    }
}
  • Zeile 101: die Artikeltabelle, die von allen Threads gemeinsam genutzt wird. Der Zugriff darauf wird durch die Sperre in Zeile 102 geschützt;
  • Zeile 108: Die Methode [InsertArticle] ruft eine eventuelle Transaktion ab, die die Schicht [business] in den lokalen Daten des aktuellen Threads abgelegt hat;
  • Zeilen 111–113: Die Tabelle hat eine Eindeutigkeitsbedingung für Artikelnamen: Das Einfügen eines Artikels mit einem bereits vorhandenen Namen löst eine Ausnahme aus;
  • Zeile 115: Der eingefügte Artikel ist eine Kopie des erhaltenen Artikels mit einem von der Schicht [dao] vergebenen Bezeichner. Der Ausdruck [with] erstellt eine Kopie eines [record] , wobei bestimmte Eigenschaften geändert werden;
  • Zeilen 118–122: Läuft eine Transaktion, nimmt die Schicht [dao] daran teil, indem sie festhält, wie das Einfügen rückgängig gemacht wird. Der Operator [?.] ruft [Log] nur auf, wenn [transaction] nicht [null] ist;
  • Zeile 125: Eine Ablaufmeldung zeigt den Thread, den eingefügten Artikel und gegebenenfalls die Transaktion an;
  • Zeilen 131–135: Die zurückgegebene Artikelliste ist eine Kopie der Tabelle (Collection-Ausdruck [.. table]), damit der Aufrufer sie nicht durchläuft, während ein anderer Thread sie verändert.

Die Schicht [business] sieht wie folgt aus:

// die [business]-Schicht
interface IBusiness
{
    void InsertArticlesInTransaction(Article[] articles);
    void InsertArticlesOutOfTransaction(Article[] articles);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

class Business(IDao dao) : IBusiness
{
    // Einfügen eines Artikel-Arrays: alles oder nichts
    public void InsertArticlesInTransaction(Article[] articles)
    {
        // Beginn der Transaktion, gespeichert in den threadlokalen Daten
        var transaction = new Transaction();
        ThreadContext.Transaction.Value = transaction;
        try
        {
            foreach (Article article in articles)
            {
                // die [dao]-Schicht findet die Transaktion im Thread
                dao.InsertArticle(article);
                // simulierte Verarbeitung, die anderen Threads Gelegenheit zum Eingreifen gibt
                Thread.Sleep(200);
            }
            transaction.Commit();
            Console.WriteLine($"[{Thread.CurrentThread.Name}] [business] transaction {transaction.Number} committed");
        }
        catch
        {
            transaction.Rollback();
            Console.WriteLine($"[{Thread.CurrentThread.Name}] [business] transaction {transaction.Number} rolled back");
            throw;
        }
        finally
        {
            // der Thread hat keine laufende Transaktion mehr
            ThreadContext.Transaction.Value = null;
        }
    }

    // Einfügen eines Artikel-Arrays ohne Transaktion
    public void InsertArticlesOutOfTransaction(Article[] articles)
    {
        foreach (Article article in articles)
        {
            dao.InsertArticle(article);
        }
    }

    public List<Article> GetAllArticles() => dao.GetAllArticles();
    public void DeleteAllArticles() => dao.DeleteAllArticles();
}
  • Zeile 157: Die Schicht [dao] wird durch den primären Konstruktor injiziert;
  • Zeilen 163–164: Die Methode [InsertArticlesInTransaction] startet eine Transaktion und speichert sie in den lokalen Daten des Threads;
  • Zeile 170: Die Einfügemethode der Schicht [dao] wird für jeden Artikel aufgerufen, ohne dass ihr die Transaktion übergeben wird;
  • Zeile 172: Eine Pause simuliert eine Verarbeitung, um einem anderen Thread Zeit zu geben, während der Transaktion einzugreifen (dritter Teil des Testprogramms);
  • Zeile 174: Erreicht das Programm diese Stelle, ist keine Ausnahme aufgetreten: Die Transaktion wird bestätigt (Commit);
  • Zeilen 177–181: Tritt eine Ausnahme auf, wird die Transaktion zurückgerollt und die Ausnahme erneut an den Aufrufer ausgelöst;
  • Zeile 186: In jedem Fall hat der Thread keine aktive Transaktion mehr. Das ist wichtig, wenn der Thread wiederverwendet wird (Pool-Thread);
  • Zeile 191: dasselbe Einfügen, ohne Transaktion.

Das Testprogramm lautet wie folgt:

// threadlokale Daten: die [business]-Schicht legt die Transaktion dort ab, die [dao]-Schicht findet sie dort

// die Schichten der Anwendung
IDao dao = new Dao();
IBusiness business = new Business(dao);
Thread.CurrentThread.Name = "Main";

// zwei Artikel mit demselben Namen: der zweite verletzt die Eindeutigkeitsbedingung auf dem Namen
Article[] articles = [new(0, "article", 100, 10, 1), new(0, "article", 100, 10, 1)];

// 1 - Einfügen außerhalb einer Transaktion
Console.WriteLine("Inserting the articles outside a transaction...");
Execute(() => business.InsertArticlesOutOfTransaction(articles));
DisplayArticles(business);

// 2 - Einfügen innerhalb einer Transaktion
business.DeleteAllArticles();
Console.WriteLine("Inserting the articles inside a transaction...");
Execute(() => business.InsertArticlesInTransaction(articles));
DisplayArticles(business);

// 3 - zwei gleichzeitige Threads: die Transaktion von Thread A ist für Thread B nicht sichtbar
business.DeleteAllArticles();
Console.WriteLine("Two simultaneous threads...");
Article[] articlesA = [new(0, "keyboard", 20, 5, 1), new(0, "mouse", 10, 5, 1), new(0, "keyboard", 20, 5, 1)];
Article[] articlesB = [new(0, "screen", 150, 2, 1)];
var threadA = new Thread(() => Execute(() => business.InsertArticlesInTransaction(articlesA))) { Name = "A" };
var threadB = new Thread(() => Execute(() => business.InsertArticlesOutOfTransaction(articlesB))) { Name = "B" };
threadA.Start();
Thread.Sleep(100);
threadB.Start();
threadA.Join();
threadB.Join();
DisplayArticles(business);

// führt eine Aktion aus und zeigt dabei die mögliche Ausnahme an
static void Execute(Action action)
{
    try
    {
        action();
    }
    catch (Exception e)
    {
        Console.WriteLine($"[{Thread.CurrentThread.Name}] {e.GetType().Name} : {e.Message}");
    }
}

// zeigt die Artikelliste an
static void DisplayArticles(IBusiness business)
{
    Console.WriteLine("List of articles:");
    foreach (Article article in business.GetAllArticles())
    {
        Console.WriteLine($"  {article}");
    }
}
  • Zeile 9: Wir erstellen ein Array mit zwei Artikeln desselben Namens. Das Einfügen des zweiten Artikels wird abgelehnt. Erfolgt das Einfügen außerhalb einer Transaktion, wird der erste Artikel eingefügt und bleibt im Array. Erfolgt es innerhalb einer Transaktion, wird der erste Artikel eingefügt und beim Rollback der Transaktion wieder entfernt;
  • Zeilen 11–14: Das Array wird außerhalb einer Transaktion eingefügt, danach wird die Tabelle angezeigt;
  • Zeilen 16–20: dasselbe Vorgehen innerhalb einer Transaktion;
  • Zeilen 22–34: Zwei Threads arbeiten gleichzeitig. Thread A fügt drei Artikel innerhalb einer Transaktion ein (der dritte verletzt die Eindeutigkeitsbedingung); währenddessen fügt Thread B einen Artikel außerhalb einer Transaktion ein;
  • Zeilen 37–45: Die Funktion [Execute] führt eine Aktion aus und zeigt eine eventuelle Ausnahme an, dem Threadnamen vorangestellt.

Ergebnisse:

> dotnet run threads-24.cs
Inserting the articles outside a transaction...
[Main] [dao] insertion of article (id 1) outside a transaction
[Main] InvalidOperationException : an article named [article] already exists
List of articles:
  Article { Id = 1, Name = article, Price = 100, CurrentStock = 10, MinimumStock = 1 }
Inserting the articles inside a transaction...
[Main] [dao] insertion of article (id 2) in transaction 1
[Main] [business] transaction 1 rolled back
[Main] InvalidOperationException : an article named [article] already exists
List of articles:
Two simultaneous threads...
[A] [dao] insertion of keyboard (id 3) in transaction 2
[B] [dao] insertion of screen (id 4) outside a transaction
[A] [dao] insertion of mouse (id 5) in transaction 2
[A] [business] transaction 2 rolled back
[A] InvalidOperationException : an article named [keyboard] already exists
List of articles:
  Article { Id = 4, Name = screen, Price = 150, CurrentStock = 2, MinimumStock = 1 }
  • Das Einfügen außerhalb der Transaktion ließ den ersten Datensatz in der Tabelle zurück (Zeile 6);
  • das Einfügen innerhalb einer Transaktion ließ keine Datensätze in der Tabelle zurück: Der Datensatz mit der ID 2 wurde durch den Rollback entfernt;
  • Im dritten Teil fügte Thread B den Bildschirm ein, während die Transaktion 2 von Thread A lief: Er tat dies außerhalb der Transaktion, da die Transaktion eine lokale Variable von Thread A ist. Der Rollback der Transaktion 2 entfernte die von A eingefügte Tastatur und Maus, nicht aber den von B eingefügten Bildschirm.

8.10.3. Fazit

Das vorherige Beispiel zeigte den Nutzen threadlokaler Daten für die Transaktionsverwaltung. Es sollte nicht unverändert übernommen werden. .NET stellt diesen Mechanismus von Haus aus mit der Klasse [System.Transactions.TransactionScope] bereit: eine „Ambient“-Transaktion, die über [Transaction.Current] zugänglich ist und an der Datenbankverbindungen automatisch teilnehmen. Frameworks wie Entity Framework Core verwalten Transaktionen ebenfalls, ohne dass der Code der Schicht [dao] sich darum kümmern muss. Und in heutigen Webanwendungen, die asynchron sind, wird diese Kontextinformation von [AsyncLocal<T>] statt von threadlokalen Daten getragen.

8.11. Weiterführende Literatur

Die Thread-Synchronisation ist ein anspruchsvolles Gebiet. Dieses Kapitel hat die wichtigsten Werkzeuge vorgestellt; zum Weiterlernen:

  • Die Dokumentation von Microsoft, Kapitel „Threading in .NET“: Managed threading, insbesondere die Seite „Overview of synchronization primitives“;
  • die Dokumentation von Microsoft, Kapitel „Parallel Programming“: Parallel Programming in .NET, das die Bibliothek [Parallel], Tasks und nebenläufige Collections behandelt;
  • das Kapitel „Threading“ aus dem Buch von Joseph Albahari, [C# in a Nutshell], für das der Kurs von 2008 bereits die Ausgabe zu C# 3.0 empfahl. Eine ältere, aber noch immer lehrreiche Version dieses Kapitels ist online verfügbar: Threading in C#.

In modernem Code werden [Thread]-Objekte nur selten direkt verwendet. Stattdessen werden Tasks ([Task]) bevorzugt, da sie im Thread-Pool laufen, und vor allem die asynchrone Programmierung mit den Schlüsselwörtern [async] und [await], die es erlaubt, auf eine lang laufende Operation (Netzwerk-, Datenbank- oder Dateizugriff) zu warten, ohne einen Thread zu blockieren. Dies ist das Thema des nächsten Kapitels. Dennoch bleiben die in diesem Kapitel behandelten Konzepte unverzichtbar: Tasks laufen in Threads, und die Daten, die sie gemeinsam nutzen, müssen mit denselben Werkzeugen geschützt werden ([lock], [Interlocked], nebenläufige Collections).