Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C#

Monitor — bloccare e attendere una condizione

System.Threading.Monitor combina l’esclusione reciproca con l’attesa di modifiche a uno stato condiviso. Enter ed Exit gestiscono il blocco, TryEnter può limitare l’attesa per acquisirlo e Wait, Pulse e PulseAll coordinano i thread.

Versione: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification

Sintassi

Monitor.Enter(gate, ref lockTaken);
Monitor.Exit(gate);
bool acquired = Monitor.TryEnter(gate, millisecondsTimeout);
bool signaled = Monitor.Wait(gate);
Monitor.Pulse(gate);
Monitor.PulseAll(gate);

System.Threading.Monitor protegge lo stato condiviso con un blocco associato a un oggetto specifico. Tutti i thread che collaborano devono usare la stessa istanza, preferibilmente un readonly object privato. Evita le stringhe e i valori soggetti a boxing. Queste API sono disponibili in .NET 10; l’esempio non richiede funzionalità del linguaggio in preview.

Monitor.Enter attende di acquisire il blocco e Monitor.Exit lo rilascia. Il blocco è rientrante: lo stesso thread può acquisirlo più volte, ma deve chiamare Exit altrettante volte. Rilascialo in finally; con Enter(gate, ref lockTaken), inizializza lockTaken = false e chiama Exit solo dopo aver acquisito il blocco. Monitor.TryEnter tenta l’acquisizione senza attesa o con un timeout; l’overload che restituisce bool indica se è riuscita.

Monitor.Wait richiede che il thread possieda il blocco: lo rilascia e blocca il thread, quindi lo riacquisisce prima di restituire il controllo normalmente. Monitor.Pulse notifica un thread in attesa, mentre Monitor.PulseAll li notifica tutti. La notifica non rilascia il blocco né lo trasferisce immediatamente. I segnali non vengono memorizzati se nessuno è in attesa. Verifica la condizione con while, non con if: lo stato potrebbe essere cambiato quando il blocco viene riacquisito. Il timeout di Wait non limita il tempo necessario per riacquisire il blocco.

Chiamare Wait, Pulse, PulseAll o Exit senza possedere il blocco corrispondente genera SynchronizationLockException. Il possesso di un monitor è legato al thread; non mantenerlo attraverso await. Per un normale object, l’istruzione lock usa un monitor. Da C# 13, lock su un’espressione di tipo System.Threading.Lock usa un meccanismo diverso: non combinarlo con Monitor.Wait o con le notifiche del monitor.

Esempi

using System;
using System.Threading;

internal static class Program
{
    private static readonly object gate = new();
    private static bool ready;
    private static int value;

    private static void Main()
    {
        var consumer = new Thread(() =>
        {
            bool lockTaken = false;
            try
            {
                Monitor.Enter(gate, ref lockTaken);
                while (!ready)
                    Monitor.Wait(gate);
                Console.WriteLine(value);
            }
            finally
            {
                if (lockTaken)
                    Monitor.Exit(gate);
            }
        });

        consumer.Start();
        lock (gate)
        {
            value = 42;
            ready = true;
            Monitor.PulseAll(gate);
        }
        consumer.Join();
    }
}

Risultato

42

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti