EventWaitHandle Třída

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Threading.dll

Zdroj:

EventWaitHandle.cs

Představuje událost synchronizace vláken.

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

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Dědičnost

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Odvozené

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

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, až vlákno dokončí úlohu.

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

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í signálem. Obvykle jeden nebo více vláken blokuje na jednom EventWaitHandle nebo více vláknech, dokud neblokované vlákno volá Set metodu, uvolnění jednoho nebo více blokovaných vláken. Vlákno může signalizovat EventWaitHandle a pak ho zablokovat voláním metody static (Shared v Visual Basic) WaitHandle.SignalAndWait.

Note

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

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

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

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

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

Další informace najdete v části Interakce s vlákny nebo signalizační část článku Přehled primitiv synchronizace .

Caution

Ve výchozím nastavení není pojmenovaná událost omezena na uživatele, který ji vytvořil. Ostatní uživatelé můžou událost otevřít a používat, včetně narušení události nastavením nebo nevhodným resetováním události. Chcete-li omezit přístup na konkrétní uživatele, můžete použít přetížení konstruktoru nebo EventWaitHandleAcl předat EventWaitHandleSecurity při vytváření pojmenované události. 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 se spuštěným kódem.

Konstruktory

Name	Description
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je obslužná rutina čekání původně signalizována v důsledku tohoto volání, zda se resetuje automaticky nebo ručně, název události synchronizace systému a logická proměnná, jejíž hodnota po volání označuje, zda pojmenovaná systémová událost byla vytvořena.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions, Boolean)	Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je obslužná rutina čekání původně signalizována, pokud je vytvořena v důsledku tohoto volání, zda se resetuje automaticky nebo ručně, název události synchronizace systému, možnosti nastavení přístupu k oboru uživatele a relace oboru a logická proměnná, jejíž hodnota po volání označuje, zda pojmenovaná systémová událost byla vytvořena.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions)	Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je čekací popisovač původně signalizován, pokud je vytvořen v důsledku tohoto volání, zda se resetuje automaticky nebo ručně, název události synchronizace systému a možnosti pro nastavení přístupu v oboru uživatele a relace.
EventWaitHandle(Boolean, EventResetMode, String)	Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je obslužná rutina čekání původně signalizována, pokud je vytvořena v důsledku tohoto volání, zda se resetuje automaticky nebo ručně, a název události synchronizace systému.
EventWaitHandle(Boolean, EventResetMode)	Inicializuje novou instanci EventWaitHandle třídy, určuje, zda je obslužná rutina čekání původně signalizována a zda se resetuje automaticky nebo ručně.

Pole

Name	Description
WaitTimeout	Označuje, že WaitAny(WaitHandle[], Int32, Boolean) operace vypršela před signálem jakéhokoli z popisovačů čekání. Toto pole je konstantní. (Zděděno od WaitHandle)

Vlastnosti

Name	Description
Handle	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

Name	Description
Close()	Uvolní všechny prostředky uchovávané aktuálním WaitHandle. (Zděděno od WaitHandle)
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é nástrojem WaitHandlea 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)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Otevře zadanou pojmenovanou událost synchronizace, pokud již existuje. Pokud jsou možnosti nastaveny pouze na aktuálního uživatele, ověří se u volajícího uživatele řízení přístupu objektu.
OpenExisting(String)	Otevře zadanou pojmenovanou událost synchronizace, pokud již existuje.
Reset()	Nastaví stav události na nepřiřazené, což způsobuje blokování vláken.
Set()	Nastaví stav události, která signalizovala, což umožňuje pokračování jednoho nebo více čekacích vláken.
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, jestli operace proběhla úspěšně.
TryOpenExisting(String, NamedWaitHandleOptions, EventWaitHandle)	Otevře zadanou pojmenovanou událost synchronizace, pokud již existuje, a vrátí hodnotu, která označuje, jestli operace proběhla úspěšně. Pokud jsou možnosti nastaveny pouze na aktuálního uživatele, ověří se u volajícího uživatele řízení přístupu objektu.
WaitOne()	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál. (Zděděno od WaitHandle)
WaitOne(Int32, Boolean)	Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určí časový interval a určí, jestli se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)
WaitOne(Int32)	Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určuje časový interval v milisekundách. (Zděděno od WaitHandle)
WaitOne(TimeSpan, Boolean)	Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan a určí, zda se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)
WaitOne(TimeSpan)	Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí TimeSpan k určení časového intervalu. (Zděděno od WaitHandle)

Metody rozšíření

Name	Description
GetAccessControl(EventWaitHandle)	Vrátí popisovače zabezpečení pro zadanou handlehodnotu .
GetSafeWaitHandle(WaitHandle)	Získá bezpečný popisovač pro nativní obslužný rutina čekání operačního systému.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Nastaví popisovače zabezpečení pro zadaný popisovač čekání na událost.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Nastaví bezpečný popisovač pro nativní obslužný rutinu čekání operačního systému.

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

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

Viz také

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• spravovaných vláken
• Přehled primitiv synchronizace