EventWaitHandle Classe

Definizione

Spazio dei nomi:

System.Threading

Assembly:

netstandard.dll, System.Threading.dll

Origine:

EventWaitHandle.cs

Rappresenta un evento di sincronizzazione thread.

public ref class EventWaitHandle : System::Threading::WaitHandle

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Ereditarietà

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Derivato

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Esempio

Nell'esempio di codice seguente viene usato l'overload del SignalAndWait(WaitHandle, WaitHandle) metodo per consentire al thread principale di segnalare un thread bloccato e quindi attendere il completamento di un'attività da parte del thread.

L'esempio avvia cinque thread e consente loro di bloccarsi su un EventWaitHandle creato con il EventResetMode.AutoReset flag, quindi rilascia un thread ogni volta che l'utente preme il tasto INVIO . L'esempio accoda quindi altri cinque thread e li rilascia tutti usando un EventWaitHandle oggetto creato con il EventResetMode.ManualReset flag .

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();
    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Imports System.Threading

Public Class Example

    ' The EventWaitHandle used to demonstrate the difference
    ' between AutoReset and ManualReset synchronization events.
    '
    Private Shared ewh As EventWaitHandle

    ' A counter to make sure all threads are started and
    ' blocked before any are released. A Long is used to show
    ' the use of the 64-bit Interlocked methods.
    '
    Private Shared threadCount As Long = 0

    ' An AutoReset event that allows the main thread to block
    ' until an exiting thread has decremented the count.
    '
    Private Shared clearCount As New EventWaitHandle(False, _
        EventResetMode.AutoReset)

    <MTAThread> _
    Public Shared Sub Main()

        ' Create an AutoReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.AutoReset)

        ' Create and start five numbered threads. Use the
        ' ParameterizedThreadStart delegate, so the thread
        ' number can be passed as an argument to the Start 
        ' method.
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        ' When multiple threads use a 64-bit value on a 32-bit
        ' system, you must access the value through the
        ' Interlocked class to guarantee thread safety.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Release one thread each time the user presses ENTER,
        ' until all threads have been released.
        '
        While Interlocked.Read(threadCount) > 0
            Console.WriteLine("Press ENTER to release a waiting thread.")
            Console.ReadLine()

            ' SignalAndWait signals the EventWaitHandle, which
            ' releases exactly one thread before resetting, 
            ' because it was created with AutoReset mode. 
            ' SignalAndWait then blocks on clearCount, to 
            ' allow the signaled thread to decrement the count
            ' before looping again.
            '
            WaitHandle.SignalAndWait(ewh, clearCount)
        End While
        Console.WriteLine()

        ' Create a ManualReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.ManualReset)

        ' Create and start five more numbered threads.
        '
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Because the EventWaitHandle was created with
        ' ManualReset mode, signaling it releases all the
        ' waiting threads.
        '
        Console.WriteLine("Press ENTER to release the waiting threads.")
        Console.ReadLine()
        ewh.Set()
        
    End Sub

    Public Shared Sub ThreadProc(ByVal data As Object)
        Dim index As Integer = CInt(data)

        Console.WriteLine("Thread {0} blocks.", data)
        ' Increment the count of blocked threads.
        Interlocked.Increment(threadCount)

        ' Wait on the EventWaitHandle.
        ewh.WaitOne()

        Console.WriteLine("Thread {0} exits.", data)
        ' Decrement the count of blocked threads.
        Interlocked.Decrement(threadCount)

        ' After signaling ewh, the main thread blocks on
        ' clearCount until the signaled thread has 
        ' decremented the count. Signal it now.
        '
        clearCount.Set()
    End Sub
End Class

Commenti

La EventWaitHandle classe consente ai thread di comunicare tra loro segnalando. In genere, uno o più thread si bloccano in un oggetto EventWaitHandle finché un thread sbloccato non chiama il Set metodo, rilasciando uno o più thread bloccati. Un thread può segnalare un EventWaitHandle e quindi bloccarlo chiamando il metodo static (Shared in Visual Basic) WaitHandle.SignalAndWait.

Note

La EventWaitHandle classe fornisce l'accesso agli eventi di sincronizzazione del sistema denominati.

Il comportamento di un oggetto EventWaitHandle segnalato dipende dalla modalità di reimpostazione. Un EventWaitHandle oggetto creato con il EventResetMode.AutoReset flag viene reimpostato automaticamente quando viene segnalato, dopo il rilascio di un singolo thread in attesa. Un EventWaitHandle oggetto creato con il EventResetMode.ManualReset flag rimane segnalato fino a quando non viene chiamato il relativo Reset metodo.

Gli eventi di reimpostazione automatica consentono l'accesso esclusivo a una risorsa. Se viene segnalato un evento di reimpostazione automatica quando non è in attesa alcun thread, rimane segnalato fino a quando un thread non tenta di attenderlo. L'evento libera il thread e si resetta immediatamente, bloccando i thread successivi.

Gli eventi di reimpostazione manuale sono come gate. Quando l'evento non viene segnalato, i thread che attendono verranno bloccati. Quando viene segnalato l'evento, tutti i thread in attesa vengono rilasciati e l'evento rimane segnalato (ovvero, le attese successive non vengono bloccate) fino a quando non viene chiamato il relativo Reset metodo. Gli eventi di reimpostazione manuale sono utili quando un thread deve completare un'attività prima che altri thread possano continuare.

gli oggetti EventWaitHandle possono essere usati con i metodi static(Shared in Visual Basic) WaitHandle.WaitAll e WaitHandle.WaitAny.

Per altre informazioni, vedere la sezione Interazione tra thread o segnalazione dell'articolo Panoramica delle primitive di sincronizzazione .

Caution

Per impostazione predefinita, un evento denominato non è limitato all'utente che lo ha creato. Altri utenti potrebbero essere in grado di aprire e usare l'evento, inclusa l'interazione con l'evento impostandolo o reimpostandolo in modo inappropriato. Per limitare l'accesso a utenti specifici, è possibile usare un overload del costruttore o EventWaitHandleAcl passare un EventWaitHandleSecurity oggetto durante la creazione dell'evento denominato. Evitare di usare eventi denominati senza restrizioni di accesso nei sistemi che potrebbero avere utenti non attendibili che eseguono codice.

Costruttori

Nome	Descrizione
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Inizializza una nuova istanza della EventWaitHandle classe , specificando se l'handle di attesa viene inizialmente segnalato se creato in seguito a questa chiamata, se viene reimpostato automaticamente o manualmente, il nome di un evento di sincronizzazione del sistema e una variabile booleana il cui valore dopo la chiamata indica se l'evento di sistema denominato è stato creato.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions, Boolean)	Inizializza una nuova istanza della EventWaitHandle classe , specificando se l'handle di attesa viene inizialmente segnalato se creato in seguito a questa chiamata, se reimposta automaticamente o manualmente, il nome di un evento di sincronizzazione del sistema, le opzioni per impostare l'ambito utente e l'accesso all'ambito sessione e una variabile booleana il cui valore dopo la chiamata indica se è stato creato l'evento di sistema denominato.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions)	Inizializza una nuova istanza della EventWaitHandle classe , specificando se l'handle di attesa viene inizialmente segnalato se creato in seguito a questa chiamata, se reimposta automaticamente o manualmente, il nome di un evento di sincronizzazione del sistema e le opzioni per impostare l'ambito utente e l'accesso all'ambito sessione.
EventWaitHandle(Boolean, EventResetMode, String)	Inizializza una nuova istanza della EventWaitHandle classe , specificando se l'handle di attesa viene inizialmente segnalato se creato in seguito a questa chiamata, se viene reimpostato automaticamente o manualmente e il nome di un evento di sincronizzazione del sistema.
EventWaitHandle(Boolean, EventResetMode)	Inizializza una nuova istanza della EventWaitHandle classe , specificando se l'handle di attesa viene inizialmente segnalato e se viene reimpostato automaticamente o manualmente.

Campi

Nome	Descrizione
WaitTimeout	Indica che si è verificato un timeout di un'operazione WaitAny(WaitHandle[], Int32, Boolean) prima che uno degli handle di attesa sia stato segnalato. Questo campo è costante. (Ereditato da WaitHandle)

Proprietà

Nome	Descrizione
Handle	Obsoleti. Ottiene o imposta l'handle nativo del sistema operativo. (Ereditato da WaitHandle)
SafeWaitHandle	Ottiene o imposta l'handle nativo del sistema operativo. (Ereditato da WaitHandle)

Metodi

Nome	Descrizione
Close()	Rilascia tutte le risorse contenute nell'oggetto corrente WaitHandle. (Ereditato da WaitHandle)
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della WaitHandle classe . (Ereditato da WaitHandle)
Dispose(Boolean)	In caso di override in una classe derivata, rilascia le risorse non gestite usate da WaitHandlee, facoltativamente, rilascia le risorse gestite. (Ereditato da WaitHandle)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto corrente MarshalByRefObject . (Ereditato da MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Apre l'evento di sincronizzazione denominato specificato, se esiste già. Se le opzioni sono impostate solo sull'utente corrente, i controlli di accesso dell'oggetto vengono verificati per l'utente chiamante.
OpenExisting(String)	Apre l'evento di sincronizzazione denominato specificato, se esiste già.
Reset()	Imposta lo stato dell'evento su non firmato, causando il blocco dei thread.
Set()	Imposta lo stato dell'evento su segnalato, consentendo l'esecuzione di uno o più thread in attesa.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TryOpenExisting(String, EventWaitHandle)	Apre l'evento di sincronizzazione denominato specificato, se esiste già, e restituisce un valore che indica se l'operazione è riuscita.
TryOpenExisting(String, NamedWaitHandleOptions, EventWaitHandle)	Apre l'evento di sincronizzazione denominato specificato, se esiste già, e restituisce un valore che indica se l'operazione è riuscita. Se le opzioni sono impostate solo sull'utente corrente, i controlli di accesso dell'oggetto vengono verificati per l'utente chiamante.
WaitOne()	Blocca il thread corrente fino a quando l'oggetto corrente WaitHandle non riceve un segnale. (Ereditato da WaitHandle)
WaitOne(Int32, Boolean)	Blocca il thread corrente fino a quando l'oggetto corrente WaitHandle non riceve un segnale, utilizzando un intero con segno a 32 bit per specificare l'intervallo di tempo e specificando se uscire dal dominio di sincronizzazione prima dell'attesa. (Ereditato da WaitHandle)
WaitOne(Int32)	Blocca il thread corrente fino a quando l'oggetto corrente WaitHandle non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo in millisecondi. (Ereditato da WaitHandle)
WaitOne(TimeSpan, Boolean)	Blocca il thread corrente fino a quando l'istanza corrente non riceve un segnale, utilizzando un TimeSpan oggetto per specificare l'intervallo di tempo e specificando se uscire dal dominio di sincronizzazione prima dell'attesa. (Ereditato da WaitHandle)
WaitOne(TimeSpan)	Blocca il thread corrente fino a quando l'istanza corrente non riceve un segnale, usando un TimeSpan oggetto per specificare l'intervallo di tempo. (Ereditato da WaitHandle)

Metodi di estensione

Nome	Descrizione
GetAccessControl(EventWaitHandle)	Restituisce i descrittori di sicurezza per l'oggetto specificato handle.
GetSafeWaitHandle(WaitHandle)	Ottiene l'handle sicuro per un handle di attesa del sistema operativo nativo.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Imposta i descrittori di sicurezza per l'handle di attesa dell'evento specificato.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Imposta un handle sicuro per un handle di attesa del sistema operativo nativo.

Thread safety

Questo tipo è thread-safe.

Vedi anche

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• di threading gestito
• Panoramica delle primitive di sincronizzazione