Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C#

Thread.Start/Join e Monitor.Wait/PulseAll: thread e condizioni

Avvia un thread reale, usa un monitor per attendere una modifica dello stato condiviso e attendi separatamente la fine del thread. Una notifica non dimostra che la condizione sia soddisfatta.

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

Sintassi

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 e .NET 8, i metodi di istanza di Thread, nello spazio dei nomi System.Threading, gestiscono il ciclo di vita del thread. Start() ne pianifica l’esecuzione senza attendere la fine del delegato. Start(object?) passa un argomento a ParameterizedThreadStart; con ThreadStart, questo overload genera InvalidOperationException. Start() passa null a ParameterizedThreadStart. Avviare lo stesso thread una seconda volta genera ThreadStateException, anche dopo la sua terminazione.

Join() blocca il chiamante fino alla fine del thread di destinazione. Gli overload con int (millisecondi) o TimeSpan restituiscono true se il thread è terminato, oppure false se è scaduto il tempo di attesa. Join non ferma il thread e genera ThreadStateException se questo non è stato avviato. Non chiamare Join() senza limite sul thread corrente né mentre detieni un lock necessario al thread di destinazione: rischi un deadlock.

Usa lo stesso oggetto dedicato gate, non esposto all’esterno, per leggere e scrivere lo stato condiviso. Con un object, lock (gate) usa Monitor.Enter e Monitor.Exit e rilascia il lock anche in caso di eccezione; TryEnter tenta di acquisire il lock, non di attendere una condizione. I metodi statici Monitor.Wait(gate) e Monitor.PulseAll(gate) richiedono che il chiamante detenga quel lock, altrimenti generano SynchronizationLockException. Wait rilascia temporaneamente solo quel lock e lo riacquisisce prima di ritornare, ripristinando il livello di rientranza. Gli overload con limite di tempo (int in millisecondi o TimeSpan) restituiscono un bool relativo al tempo, non alla condizione. La riacquisizione del lock può richiedere più del tempo indicato. Gli overload che accettano exitContext sono disponibili in .NET 8, ma il runtime ignora questo argomento.

Con il lock acquisito, modifica lo stato prima di chiamare PulseAll. Sposta tutti i thread in attesa su quel monitor nella coda dei thread pronti (Pulse ne sposta solo uno), ma non rilascia il lock né conserva un segnale per chi si metterà in attesa più tardi. Verifica la condizione in un while, non in un if: un altro thread potrebbe modificare lo stato prima che tu riacquisisca il lock. È un protocollo bloccante, non await; l’esempio è per una console .NET 8, non per un browser.

Esempi

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

Risultato

Result: 42
Worker finished.

Il thread principale chiama `Start()` mentre detiene il lock su `gate`, quindi il thread di lavoro non può impostare `ready` finché `Wait` non rilascia il lock. Dopo averlo riacquisito, il thread principale legge `result`, esce da `lock` e solo allora chiama `Join()`. Le righe previste sono `Result: 42` e `Worker finished.`, in quest’ordine.

Lezioni correlate

  • C# · Lezione 17 · Avanzato · Versione: 3

Fonti