EventWaitHandle Klasse

Definition

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

public class EventWaitHandle : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(true)]
public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(true)>]
type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Vererbung

Object

WaitHandle

EventWaitHandle

Vererbung

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Abgeleitet

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Attribute

ComVisibleAttribute

Beispiele

Im folgenden Codebeispiel wird die SignalAndWait(WaitHandle, WaitHandle) Methodenüberladung verwendet, um dem Hauptthread das Signal eines blockierten Threads zu ermöglichen und dann zu warten, bis der Thread eine Aufgabe beendet hat.

Das Beispiel startet fünf Threads und ermöglicht es ihnen, für ein EventWaitHandle erstelltes Element mit der EventResetMode.AutoReset Kennzeichnung zu blockieren, und gibt dann jedes Mal, wenn der Benutzer die EINGABETASTE drückt, einen Thread los. Im Beispiel werden dann weitere fünf Threads in die Warteschlange gestellt und alle mit der EventWaitHandleEventResetMode.ManualReset Kennzeichnung erstellt.

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

Hinweise

Die EventWaitHandle Klasse ermöglicht threads die Kommunikation miteinander durch Signalisierung. In der Regel wird mindestens ein Threads auf einem EventWaitHandle Thread blockiert, bis ein nicht blockierter Thread die Set Methode aufruft und mindestens einen der blockierten Threads freigibt. Ein Thread kann eine EventWaitHandle signalisieren und dann blockieren, indem die static (Shared in Visual Basic) WaitHandle.SignalAndWait-Methode aufgerufen wird.

Das Verhalten eines signalisierten Elements EventWaitHandle hängt vom Zurücksetzungsmodus ab. Ein EventWaitHandle mit der EventResetMode.AutoReset Kennzeichnung erstelltes Element wird automatisch zurückgesetzt, wenn signalisiert wird, nachdem ein einzelner Wartethread freigegeben wurde. Eine mit der EventWaitHandle-Flag erstellte EventResetMode.ManualReset bleibt so lange ein Signal, bis die Reset-Methode aufgerufen wird.

Automatische Zurücksetzungsereignisse bieten exklusiven Zugriff auf eine Ressource. Wenn ein automatisches Reset-Ereignis signalisiert wird, wenn keine Threads warten, bleibt es signalisiert, bis ein Thread versucht, darauf zu warten. Das Ereignis gibt den Thread frei, setzt ihn sofort zurück und blockiert dabei nachfolgende Threads.

Manuelle Zurücksetzungsereignisse sind wie Tore. Wenn das Ereignis nicht signalisiert ist, werden Threads, die darauf warten, blockiert. Wenn das Ereignis signalisiert wird, werden alle Wartethreads freigegeben, und das Ereignis bleibt signalisiert (d. h. nachfolgende Wartezeiten blockieren nicht), bis die Reset Methode aufgerufen wird. Manuelle Zurücksetzungsereignisse sind nützlich, wenn ein Thread eine Aktivität abschließen muss, bevor andere Threads fortgesetzt werden können.

EventWaitHandle-Objekte können mit den Methoden static(Shared in Visual Basic) WaitHandle.WaitAll und WaitHandle.WaitAny verwendet werden.

Weitere Informationen finden Sie im Abschnitt "Threadinteraktion" oder "Signalisierung " des Artikels "Übersicht über Synchronisierungsgrundtypen" .

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Verwaltetes Thread-Management
• Übersicht über Synchronisierungsgrundtypen