KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C#

Thread.Start/Join en Monitor.Wait/PulseAll: threads en voorwaarden

Start een echte thread, gebruik een monitor om te wachten tot gedeelde toestand verandert en wacht afzonderlijk tot de thread stopt. Een melding bewijst niet dat de voorwaarde waar is.

Versie: 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 en .NET 8 beheren de instantiemethoden van Thread uit de naamruimte System.Threading de levenscyclus van een thread. Start() plant de uitvoering in zonder te wachten tot de delegate klaar is. Start(object?) geeft een argument door aan ParameterizedThreadStart; bij ThreadStart veroorzaakt deze overload een InvalidOperationException. Start() geeft null door aan ParameterizedThreadStart. Dezelfde thread opnieuw starten veroorzaakt een ThreadStateException, ook nadat de thread is gestopt.

Join() blokkeert de aanroepende thread totdat de doelthread is gestopt. De overloads met int (milliseconden) of TimeSpan geven true terug als de thread is gestopt, of false als de wachttijd is verstreken. Join stopt de thread niet en veroorzaakt een ThreadStateException als de thread nog niet is gestart. Roep Join() zonder tijdslimiet niet aan op de huidige thread of terwijl je een lock vasthoudt die de doelthread nodig heeft: dat kan een deadlock veroorzaken.

Gebruik voor elke lees- en schrijfactie van de gedeelde toestand hetzelfde afgeschermde object gate, dat alleen daarvoor dient. Met een object gebruikt lock (gate) Monitor.Enter en Monitor.Exit en geeft het de lock ook bij een uitzondering vrij; TryEnter probeert de lock te verkrijgen, niet op een voorwaarde te wachten. De statische methoden Monitor.Wait(gate) en Monitor.PulseAll(gate) vereisen dat de aanroeper die lock bezit, anders veroorzaken ze een SynchronizationLockException. Wait geeft tijdelijk alleen die lock vrij en verkrijgt hem opnieuw vóór terugkeer, met herstel van de oorspronkelijke nestingdiepte. De overloads met een tijdslimiet (int in milliseconden of TimeSpan) geven een bool terug over de tijdslimiet, niet over de voorwaarde. De lock opnieuw verkrijgen kan langer duren dan de ingestelde limiet. De overloads die exitContext accepteren, zijn beschikbaar in .NET 8, maar de runtime negeert dat argument.

Pas de toestand aan terwijl je de lock vasthoudt en roep daarna PulseAll aan. Dit verplaatst alle threads die op die monitor wachten naar de wachtrij van uitvoerbare threads (Pulse verplaatst er maar één), maar geeft de lock niet vrij en bewaart geen signaal voor latere wachtenden. Controleer de voorwaarde in een while, niet in een if: een andere thread kan de toestand wijzigen voordat jij de lock opnieuw verkrijgt. Dit is een blokkerend protocol, geen await; het voorbeeld is voor een .NET 8-console, niet voor een browser.

Voorbeelden

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.");

Resultaat

Result: 42
Worker finished.

De hoofdthread roept `Start()` aan terwijl hij de lock op `gate` vasthoudt. De workerthread kan `ready` dus pas instellen nadat `Wait` de lock vrijgeeft. Zodra de hoofdthread de lock opnieuw heeft, leest hij `result`, verlaat hij `lock` en roept hij pas daarna `Join()` aan. De verwachte regels zijn `Result: 42` en `Worker finished.`, in die volgorde.

Gerelateerde lessen

  • C# · Les 17 · Gevorderd · Versie: 3

Bronnen