EventWaitHandle Klasse

Definition

Namespace:

System.Threading

Assembly:

System.Threading.dll

Quelle:

EventWaitHandle.cs

Stellt ein Threadsynchronisierungsereignis dar.

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

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Vererbung

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Abgeleitet

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Beispiele

Im folgenden Codebeispiel wird die SignalAndWait(WaitHandle, WaitHandle) Methodenüberladung verwendet, um dem Standard Thread zu ermöglichen, einen blockierten Thread zu signalisieren und dann zu warten, bis der Thread eine Aufgabe abgeschlossen hat.

Das Beispiel startet fünf Threads und ermöglicht ihnen das Blockieren eines EventWaitHandle mit dem EventResetMode.AutoReset Flag erstellten Threads. Anschließend wird jedes Mal ein Thread freigegeben, wenn der Benutzer die EINGABETASTE drückt. Im Beispiel werden dann weitere fünf Threads in die Warteschlange gestellt und alle mithilfe eines EventWaitHandle mit dem EventResetMode.ManualReset Flag erstellten freigegeben.

using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // The EventWaitHandle used to demonstrate the difference
   // between AutoReset and ManualReset synchronization events.
   //
   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.
   //
   static __int64 threadCount = 0;

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

public:
   [MTAThread]
   static void main()
   {
      // Create an AutoReset EventWaitHandle.
      //
      ewh = gcnew 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 = gcnew Thread(
            gcnew 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( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

      // Release one thread each time the user presses ENTER,
      // until all threads have been released.
      //
      while ( Interlocked::Read( threadCount ) > 0 )
      {
         Console::WriteLine( L"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 = gcnew EventWaitHandle( false,EventResetMode::ManualReset );
      
      // Create and start five more numbered threads.
      //
      for ( int i = 0; i <= 4; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( ThreadProc ) );
         t->Start( i );
      }
      
      // Wait until all the threads have started and blocked.
      //
      while ( Interlocked::Read( threadCount ) < 5 )
      {
         Thread::Sleep( 500 );
      }

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

   }

   static void ThreadProc( Object^ data )
   {
      int index = static_cast<Int32>(data);

      Console::WriteLine( L"Thread {0} blocks.", data );
      // Increment the count of blocked threads.
      Interlocked::Increment( threadCount );
      
      // Wait on the EventWaitHandle.
      ewh->WaitOne();

      Console::WriteLine( L"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();
   }
};

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 es Threads, durch Signalisierung miteinander zu kommunizieren. In der Regel blockieren mindestens ein Threads in einem EventWaitHandle , bis ein nicht blockierter Thread die Set -Methode aufruft und mindestens einen der blockierten Threads freigibt. Ein Thread kann ein EventWaitHandle Signal signalisieren und dann blockieren, indem die static Methode (Shared in Visual Basic) WaitHandle.SignalAndWait aufgerufen wird.

Hinweis

Die EventWaitHandle -Klasse bietet Zugriff auf benannte Systemsynchronisierungsereignisse.

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

Automatische Zurücksetzungsereignisse bieten exklusiven Zugriff auf eine Ressource. Wenn ein Ereignis mit automatischer Rücksetzung als Signal verwendet wird und zu diesem Zeitpunkt keine Threads warten, bleibt es ein Signal, bis ein Thread versucht, darauf zu warten. Das Ereignis gibt den Thread frei und wird sofort zurückgesetzt, sodass nachfolgende Threads blockiert werden.

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

EventWaitHandle -Objekte können mit den staticMethoden (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 .

Achtung

Standardmäßig ist ein benanntes Ereignis nicht auf den Benutzer beschränkt, der es erstellt hat. Andere Benutzer können das Ereignis möglicherweise öffnen und verwenden, einschließlich der Störung des Ereignisses, indem sie es unangemessen festlegen oder zurücksetzen. Wenn Sie den Zugriff auf bestimmte Benutzer einschränken möchten, können Sie eine Konstruktorüberladung oder EventWaitHandleAcl einen verwenden und beim Erstellen des benannten Ereignisses EventWaitHandleSecurity übergeben. Vermeiden Sie die Verwendung benannter Ereignisse ohne Zugriffsbeschränkungen auf Systemen, auf denen möglicherweise nicht vertrauenswürdige Benutzer Code ausführen.

Konstruktoren

EventWaitHandle(Boolean, EventResetMode)	Initialisiert eine neue Instanz der EventWaitHandle-Klasse und gibt an, ob das WaitHandle anfänglich signalisiert ist und ob es automatisch oder manuell zurückgesetzt wird.
EventWaitHandle(Boolean, EventResetMode, String)	Initialisiert eine neue Instanz der EventWaitHandle-Klasse, gibt an, ob das WaitHandle anfänglich signalisiert ist, wenn es als Ergebnis dieses Aufrufs erstellt wurde, ob es automatisch oder manuell zurückgesetzt wird, und gibt den Namen eines Systemsynchronisierungsereignisses an.
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Initialisiert eine neue Instanz der EventWaitHandle-Klasse, die Folgendes angibt: ob das Wait-Handle anfänglich signalisiert wird, wenn es als Ergebnis dieses Aufrufs erstellt wird; ob es automatisch oder manuell zurückgesetzt wird; den Namen eines Systemsynchronisierungsereignisses und eine boolesche Variable, deren Wert nach dem Aufruf angibt, ob das benannte Systemereignis erstellt wurde.

Felder

WaitTimeout

Gibt an, dass ein Timeout für einen WaitAny(WaitHandle[], Int32, Boolean)-Vorgang überschritten wurde, bevor ein Signal an eines der WaitHandles gesendet wurde. Dieses Feld ist konstant. (Geerbt von WaitHandle)

Eigenschaften

Handle	Veraltet. Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Geerbt von WaitHandle)
SafeWaitHandle	Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Geerbt von WaitHandle)

Methoden

Close()	Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei. (Geerbt von WaitHandle)
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei. (Geerbt von WaitHandle)
Dispose(Boolean)	Gibt beim Überschreiben in einer abgeleiteten Klasse die von WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von WaitHandle)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
OpenExisting(String)	Öffnet das bestimmte benannte Synchronisierungsereignis, wenn es bereits vorhanden ist.
Reset()	Legt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden.
Set()	Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TryOpenExisting(String, EventWaitHandle)	Öffnet das angegebene benannte Synchronisierungsereignis, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.
WaitOne()	Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt. (Geerbt von WaitHandle)
WaitOne(Int32)	Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird. (Geerbt von WaitHandle)
WaitOne(Int32, Boolean)	Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll. (Geerbt von WaitHandle)
WaitOne(TimeSpan)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird. (Geerbt von WaitHandle)
WaitOne(TimeSpan, Boolean)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll. (Geerbt von WaitHandle)

Erweiterungsmethoden

GetAccessControl(EventWaitHandle)	Gibt die Sicherheitsbeschreibungen für den angegebenen handle zurück.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Legt die Sicherheitsbeschreibungen für das angegebene Ereigniswartehandle fest.
GetSafeWaitHandle(WaitHandle)	Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Verwaltetes Threading
• Übersicht über Synchronisierungsprimitiven