WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C#

Thread.Start/Join und Monitor.Wait/PulseAll: Threads und Bedingungen

Starte einen echten Thread, warte mit einem Monitor auf eine Änderung des gemeinsamen Zustands und warte separat auf das Threadende. Eine Benachrichtigung beweist nicht, dass die Bedingung erfüllt ist.

Version: C# 12 and .NET 8; later runtimes may add compatible features

Syntax

using System.Threading;

// Thread — instance methods
void Start();
void Start(object? parameter);
void Join();
bool Join(int millisecondsTimeout);
bool Join(TimeSpan timeout);

// Monitor — static methods
static bool Wait(object obj);
static bool Wait(object obj, int millisecondsTimeout);
static bool Wait(object obj, TimeSpan timeout);
static bool Wait(object obj, int millisecondsTimeout, bool exitContext);
static bool Wait(object obj, TimeSpan timeout, bool exitContext);
static void PulseAll(object obj);

// Waiter: check the condition while holding the monitor.
lock (gate) { while (!ready) Monitor.Wait(gate); }

// Publisher: update the condition before notifying waiters.
lock (gate) { ready = true; Monitor.PulseAll(gate); }

In C# 12 und .NET 8 steuern die Instanzmethoden von Thread aus System.Threading den Lebenszyklus eines Threads. Start() plant seine Ausführung ein, ohne auf das Ende des Delegaten zu warten. Start(object?) übergibt ParameterizedThreadStart ein Argument; bei ThreadStart löst diese Überladung InvalidOperationException aus. Start() übergibt bei ParameterizedThreadStart den Wert null. Ein zweiter Start desselben Threads löst auch nach dessen Ende ThreadStateException aus.

Join() blockiert den Aufrufer, bis der Zielthread beendet ist. Die Überladungen mit int (Millisekunden) oder TimeSpan liefern true, wenn der Thread beendet ist, oder false bei Zeitüberschreitung. Join stoppt den Thread nicht und löst bei einem noch nicht gestarteten Thread ThreadStateException aus. Rufe das unbegrenzte Join() weder für den eigenen Thread noch unter einer Sperre auf, die der Zielthread benötigt: Es droht ein Deadlock.

Verwende für alle Zugriffe auf den gemeinsamen Zustand dasselbe eigens dafür vorgesehene, nicht nach außen gegebene Objekt gate. Bei einem object nutzt lock (gate) Monitor.Enter und Monitor.Exit und gibt die Sperre auch bei einer Ausnahme frei. TryEnter versucht, die Sperre zu erwerben, statt auf eine Bedingung zu warten. Die statischen Methoden Monitor.Wait(gate) und Monitor.PulseAll(gate) setzen voraus, dass der Aufrufer diese Sperre hält; sonst lösen sie SynchronizationLockException aus. Wait gibt nur diese Sperre vorübergehend frei und erwirbt sie vor der Rückkehr mit der ursprünglichen Verschachtelungstiefe erneut. Die Überladungen mit Zeitlimit (int in Millisekunden oder TimeSpan) liefern ein bool zum Zeitlimit, nicht zur Bedingung. Der erneute Sperrerwerb kann länger als das Zeitlimit dauern. Die Überladungen mit dem Parameter exitContext sind in .NET 8 verfügbar, aber die Laufzeit ignoriert dieses Argument.

Ändere unter der Sperre erst den Zustand und rufe dann PulseAll auf. Es verschiebt alle auf diesem Monitor wartenden Threads in die Bereitschaftswarteschlange (Pulse nur einen), gibt aber weder die Sperre frei noch speichert es ein Signal für spätere Wartende. Prüfe die Bedingung mit while statt if: Ein anderer Thread kann den Zustand vor dem erneuten Sperrerwerb ändern. Das Protokoll blockiert und verwendet kein await; das Beispiel ist für eine .NET-8-Konsole gedacht, nicht für den Browser.

Beispiele

using System;
using System.Threading;

object gate = new();
bool ready = false;
int result = 0;

var worker = new Thread(() =>
{
    lock (gate)
    {
        result = 42;
        ready = true;
        Monitor.PulseAll(gate);
    }
});

int observed;
lock (gate)
{
    worker.Start();
    while (!ready)
    {
        Monitor.Wait(gate);
    }
    observed = result;
}

worker.Join();
Console.WriteLine($"Result: {observed}");
Console.WriteLine("Worker finished.");

Ergebnis

Result: 42
Worker finished.

Der Hauptthread ruft `Start()` auf, während er `gate` hält. Der Arbeitsthread kann `ready` daher erst setzen, nachdem `Wait` die Sperre freigegeben hat. Nach dem erneuten Sperrerwerb liest der Hauptthread `result`, verlässt `lock` und ruft erst dann `Join()` auf. Erwartet werden `Result: 42` und `Worker finished.`, in dieser Reihenfolge.

Zugehörige Lektionen

  • C# · Lektion 17 · Fortgeschritten · Version: 3

Quellen