Sdílet prostřednictvím


EventWaitHandle Třída

Definice

Představuje událost synchronizace vláken.

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
Dědičnost
EventWaitHandle
Dědičnost
Odvozené
Atributy

Příklady

Následující příklad kódu používá SignalAndWait(WaitHandle, WaitHandle) přetížení metody, aby hlavní vlákno signalizovalo blokované vlákno a pak počkejte, dokud vlákno nedokončí úlohu.

Příklad spustí pět vláken a umožní jim blokovat na vytvořeném EventWaitHandle s příznakem EventResetMode.AutoReset a pak uvolní jedno vlákno pokaždé, když uživatel stiskne klávesu Enter . Příklad pak zatáčí dalších pět vláken do fronty a všechna je uvolní pomocí vytvořeného EventWaitHandle s příznakem EventResetMode.ManualReset .

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

Poznámky

Třída EventWaitHandle umožňuje, aby vlákna vzájemně komunikují pomocí signalizace. Obvykle jeden nebo více vláken blokovat na, EventWaitHandle dokud odblokované vlákno volá metodu Set , uvolnění jednoho nebo více blokovaných vláken. Vlákno může signalizovat EventWaitHandle a pak ho blokovat voláním static metody (Shared v jazyce Visual Basic). WaitHandle.SignalAndWait

Poznámka

Třída EventWaitHandle poskytuje přístup k událostem pojmenované synchronizace systému.

Chování signálu EventWaitHandle závisí na jeho režimu resetování. Vytvořený EventWaitHandle s příznakem EventResetMode.AutoReset se po uvolnění jednoho čekajícího vlákna automaticky resetuje při signálu. Vytvořený EventWaitHandle s příznakem EventResetMode.ManualReset zůstává signalizovat, dokud není volána jeho Reset metoda.

Události automatického resetování poskytují výhradní přístup k prostředku. Pokud je událost automatického resetování signalizovala, když nečekají žádná vlákna, zůstane signalizovat, dokud se vlákno nepokusí na ni čekat. Událost uvolní vlákno a okamžitě resetuje, což blokuje následující vlákna.

Události ručního resetování jsou jako brány. Pokud událost není signalizovala, zablokují se vlákna, která na ni čekají. Když je událost signalována, všechna čekající vlákna jsou uvolněna a událost zůstane signalizovala (to znamená, že následná čekání neblokují) až do zavolání metody Reset . Události ručního resetování jsou užitečné, když jedno vlákno musí dokončit aktivitu, aby ostatní vlákna mohly pokračovat.

EventWaitHandle objekty lze použít s metodami static(Shared v jazyce Visual Basic) WaitHandle.WaitAll a WaitHandle.WaitAny .

Další informace najdete v části Interakce vláken nebo signalizace článku Přehled primitiv synchronizace .

Upozornění

Ve výchozím nastavení není pojmenovaná událost omezena na uživatele, který ji vytvořil. Ostatní uživatelé mohou mít možnost událost otevřít a používat, včetně toho, že událost narušují tím, že ji nastavují nebo resetují nevhodně. Pokud chcete omezit přístup na konkrétní uživatele, můžete při vytváření pojmenované události použít přetížení konstruktoru nebo EventWaitHandleAcl předat .EventWaitHandleSecurity Vyhněte se používání pojmenovaných událostí bez omezení přístupu v systémech, které můžou mít nedůvěryhodné uživatele spouštěné kódem.

Konstruktory

EventWaitHandle(Boolean, EventResetMode)

Inicializuje novou instanci EventWaitHandle třídy určením, zda je obslužná rutina čekání původně signalizována a zda se automaticky nebo ručně resetuje.

EventWaitHandle(Boolean, EventResetMode, String)

Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je popisovač čekání zpočátku signalizován, pokud je vytvořen v důsledku tohoto volání, zda se resetuje automaticky nebo ručně, a název události synchronizace systému.

EventWaitHandle(Boolean, EventResetMode, String, Boolean)

Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je obslužná rutina čekání zpočátku signalizována, pokud je vytvořena v důsledku tohoto volání, zda se automaticky nebo ručně resetuje, název události synchronizace systému a logická proměnná, jejíž hodnota po volání označuje, zda byla vytvořena pojmenovaná systémová událost.

EventWaitHandle(Boolean, EventResetMode, String, Boolean, EventWaitHandleSecurity)

Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je popisovač čekání zpočátku signalizován, pokud je vytvořen v důsledku tohoto volání, zda se automaticky nebo ručně resetuje, název události synchronizace systému, logická proměnná, jejíž hodnota po volání označuje, zda byla vytvořena pojmenovaná systémová událost, a zabezpečení řízení přístupu, které se má použít na pojmenovanou událost, pokud je vytvořena.

Pole

WaitTimeout

Označuje, že WaitAny(WaitHandle[], Int32, Boolean) časový limit operace vypršel před signálem některého z popisovačů čekání. Toto pole je konstantní.

(Zděděno od WaitHandle)

Vlastnosti

Handle
Zastaralé.
Zastaralé.

Získá nebo nastaví nativní popisovač operačního systému.

(Zděděno od WaitHandle)
SafeWaitHandle

Získá nebo nastaví nativní popisovač operačního systému.

(Zděděno od WaitHandle)

Metody

Close()

Uvolní všechny prostředky, které má aktuální WaitHandle.

(Zděděno od WaitHandle)
CreateObjRef(Type)

Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy sloužící ke komunikaci se vzdáleným objektem.

(Zděděno od MarshalByRefObject)
Dispose()

Uvolní všechny prostředky používané aktuální instancí WaitHandle třídy .

(Zděděno od WaitHandle)
Dispose(Boolean)

Při přepsání v odvozené třídě uvolní nespravované prostředky používané WaitHandlenástrojem a volitelně uvolní spravované prostředky.

(Zděděno od WaitHandle)
Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetAccessControl()

EventWaitHandleSecurity Získá objekt, který představuje zabezpečení řízení přístupu pro pojmenovanou systémovou událost reprezentovanou aktuálním EventWaitHandle objektem.

GetHashCode()

Slouží jako výchozí hashovací funkce.

(Zděděno od Object)
GetLifetimeService()
Zastaralé.

Načte aktuální životnost objektu služby, který řídí zásady životnosti pro tuto instanci.

(Zděděno od MarshalByRefObject)
GetType()

Type Získá z aktuální instance.

(Zděděno od Object)
InitializeLifetimeService()
Zastaralé.

Získá životnost objektu služby, který řídí zásady životnosti pro tuto instanci.

(Zděděno od MarshalByRefObject)
MemberwiseClone()

Vytvoří mělkou kopii aktuálního Objectsouboru .

(Zděděno od Object)
MemberwiseClone(Boolean)

Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu.

(Zděděno od MarshalByRefObject)
OpenExisting(String)

Otevře zadanou pojmenovanou událost synchronizace, pokud již existuje.

OpenExisting(String, EventWaitHandleRights)

Otevře zadanou pojmenovanou událost synchronizace, pokud již existuje, s požadovaným přístupem zabezpečení.

Reset()

Nastaví stav události na nepřiřazeno, což způsobí blokování vláken.

Set()

Nastaví stav události na signaled, což umožňuje, aby jedno nebo více čekajících vláken pokračovalo.

SetAccessControl(EventWaitHandleSecurity)

Nastaví zabezpečení řízení přístupu pro pojmenovanou událost systému.

ToString()

Vrátí řetězec, který představuje aktuální objekt.

(Zděděno od Object)
TryOpenExisting(String, EventWaitHandle)

Otevře zadanou pojmenovanou událost synchronizace, pokud již existuje, a vrátí hodnotu, která označuje, zda byla operace úspěšná.

TryOpenExisting(String, EventWaitHandleRights, EventWaitHandle)

Otevře zadanou pojmenovanou událost synchronizace( pokud již existuje) s požadovaným přístupem zabezpečení a vrátí hodnotu, která označuje, jestli operace proběhla úspěšně.

WaitOne()

Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál.

(Zděděno od WaitHandle)
WaitOne(Int32)

Blokuje aktuální vlákno, dokud aktuální WaitHandle signál neobdrží, a to pomocí 32bitového celého čísla se znaménkem pro určení časového intervalu v milisekundách.

(Zděděno od WaitHandle)
WaitOne(Int32, Boolean)

Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového celého čísla se znaménkem k určení časového intervalu a určení, zda se má doména synchronizace ukončit před čekáním.

(Zděděno od WaitHandle)
WaitOne(TimeSpan)

Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí parametru TimeSpan pro určení časového intervalu.

(Zděděno od WaitHandle)
WaitOne(TimeSpan, Boolean)

Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál, a to pomocí TimeSpan k určení časového intervalu a určení, zda má být ukončena synchronizační doména před čekáním.

(Zděděno od WaitHandle)

Explicitní implementace rozhraní

IDisposable.Dispose()

Toto rozhraní API podporuje produktovou infrastrukturu a není určené k použití přímo z uživatelského kódu.

Uvolní všechny prostředky používané nástrojem WaitHandle.

(Zděděno od WaitHandle)

Metody rozšíření

GetAccessControl(EventWaitHandle)

Vrátí popisovače zabezpečení pro zadaný handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Nastaví popisovače zabezpečení pro zadaný popisovač čekání události.

GetSafeWaitHandle(WaitHandle)

Získá bezpečný popisovač pro nativní operační systém čekání popisovač.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Nastaví bezpečný popisovač pro nativní čekací úchyt operačního systému.

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.

Viz také