EventWaitHandle Klasa

Definicja

Przestrzeń nazw:

System.Threading

Zestawy:

netstandard.dll, System.Threading.dll

Źródło:

EventWaitHandle.cs

Reprezentuje zdarzenie synchronizacji wątków.

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

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Dziedziczenie

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Pochodne

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Przykłady

W poniższym przykładzie kodu użyto SignalAndWait(WaitHandle, WaitHandle) przeciążenia metody, aby umożliwić głównemu wątkowi sygnalizowanie zablokowanego wątku, a następnie poczekaj, aż wątek zakończy zadanie.

W przykładzie uruchamia się pięć wątków i pozwala im zablokować EventWaitHandle utworzony element z EventResetMode.AutoReset flagą, a następnie zwalnia jeden wątek za każdym razem, gdy użytkownik naciska klawisz Enter . W tym przykładzie kolejkuje kolejne pięć wątków i zwalnia je wszystkie przy użyciu utworzonego EventWaitHandle z flagą 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

Uwagi

Klasa EventWaitHandle umożliwia wątkom komunikowanie się ze sobą przez sygnalizowanie. Zazwyczaj co najmniej jeden wątek blokuje się do EventWaitHandle momentu wywołania metody przez odblokowany wątek Set , zwalniając co najmniej jeden z zablokowanych wątków. Wątek może zasygnalizować EventWaitHandle, a następnie zablokować go, wywołując metodę static (Shared w Visual Basic) WaitHandle.SignalAndWait.

Note

Klasa EventWaitHandle zapewnia dostęp do nazwanych zdarzeń synchronizacji systemu.

Zachowanie EventWaitHandle , które zostało zasygnalizowane, zależy od jego trybu resetowania. Utworzony EventWaitHandle z flagą resetuje się automatycznie po zasygnalizowaniu, po zwolnieniu EventResetMode.AutoReset pojedynczego wątku oczekującego. Obiekt EventWaitHandle utworzony z flagą EventResetMode.ManualReset pozostaje zasygnalizowany do momentu wywołania metody Reset .

Zdarzenia automatycznego resetowania zapewniają wyłączny dostęp do zasobu. Jeśli zdarzenie automatycznego resetowania sygnalizuje się, gdy żadne wątki nie czekają, pozostaje w stanie zasygnalizowania, dopóki wątek nie zacznie na nie czekać. Zdarzenie zwalnia wątek i natychmiast resetuje, blokując kolejne wątki.

Zdarzenia resetowania ręcznego są takie jak bramy. Gdy zdarzenie nie jest zasygnalizowane, wątki oczekujące na to będą blokowane. Gdy zdarzenie jest zasygnalizowane, wszystkie wątki oczekujące są zwalniane, a zdarzenie pozostaje zasygnalizowane (czyli kolejne oczekiwania nie blokują) do momentu wywołania metody Reset . Zdarzenia resetowania ręcznego są przydatne, gdy jeden wątek musi wykonać działanie, zanim inne wątki będą mogły kontynuować.

EventWaitHandle obiektów można używać z metodami static(Shared in Visual Basic) WaitHandle.WaitAll i WaitHandle.WaitAny.

Aby uzyskać więcej informacji, zobacz sekcję Interakcja wątków lub sygnalizowanie w artykule Omówienie elementów pierwotnych synchronizacji .

Caution

Domyślnie nazwane zdarzenie nie jest ograniczone do użytkownika, który go utworzył. Inni użytkownicy mogą być w stanie otworzyć zdarzenie i używać go, w tym zakłócać działanie zdarzenia przez ustawienie lub zresetować je niewłaściwie. Aby ograniczyć dostęp do określonych użytkowników, możesz użyć przeciążenia konstruktora lub EventWaitHandleAcl przekazać EventWaitHandleSecurity element podczas tworzenia nazwanego zdarzenia. Unikaj używania nazwanych zdarzeń bez ograniczeń dostępu do systemów, które mogą mieć niezaufanych użytkowników z uruchomionym kodem.

Konstruktory

Nazwa	Opis
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Inicjuje nowe wystąpienie EventWaitHandle klasy, określając, czy uchwyt oczekiwania jest początkowo sygnalizowany w wyniku tego wywołania, czy resetuje automatycznie, czy ręcznie, nazwę zdarzenia synchronizacji systemu i zmienną logiczną, której wartość po wywołaniu wskazuje, czy nazwane zdarzenie systemowe zostało utworzone.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions, Boolean)	Inicjuje nowe wystąpienie EventWaitHandle klasy, określając, czy uchwyt oczekiwania jest początkowo sygnalizowany w wyniku tego wywołania, czy jest resetowany automatycznie, czy ręcznie, nazwa zdarzenia synchronizacji systemu, opcje ustawiania dostępu zakresu użytkownika i zakresu sesji oraz zmiennej logicznej, której wartość po wywołaniu wskazuje, czy nazwane zdarzenie systemowe zostało utworzone.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions)	Inicjuje nowe wystąpienie EventWaitHandle klasy, określając, czy dojście oczekiwania jest początkowo sygnalizowane w wyniku tego wywołania, czy jest resetowane automatycznie, czy ręcznie, nazwa zdarzenia synchronizacji systemu i opcje ustawiania dostępu do zakresu użytkownika i zakresu sesji.
EventWaitHandle(Boolean, EventResetMode, String)	Inicjuje nowe wystąpienie EventWaitHandle klasy, określając, czy uchwyt oczekiwania jest początkowo sygnalizowany w wyniku tego wywołania, czy jest resetowany automatycznie, czy ręcznie, oraz nazwę zdarzenia synchronizacji systemu.
EventWaitHandle(Boolean, EventResetMode)	Inicjuje nowe wystąpienie EventWaitHandle klasy, określając, czy dojście oczekiwania jest początkowo sygnalizowane, i czy resetuje się automatycznie, czy ręcznie.

Pola

Nazwa	Opis
WaitTimeout	Wskazuje, że WaitAny(WaitHandle[], Int32, Boolean) upłynął limit czasu operacji, zanim zostanie zasygnalizowana którakolwiek z dojść oczekiwania. To pole jest stałe. (Odziedziczone po WaitHandle)

Właściwości

Nazwa	Opis
Handle	Przestarzałe. Pobiera lub ustawia natywny uchwyt systemu operacyjnego. (Odziedziczone po WaitHandle)
SafeWaitHandle	Pobiera lub ustawia natywny uchwyt systemu operacyjnego. (Odziedziczone po WaitHandle)

Metody

Nazwa	Opis
Close()	Zwalnia wszystkie zasoby przechowywane przez bieżący WaitHandleelement . (Odziedziczone po WaitHandle)
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące wystąpienie WaitHandle klasy. (Odziedziczone po WaitHandle)
Dispose(Boolean)	Po zastąpieniu w klasie pochodnej zwalnia niezarządzane zasoby używane przez WaitHandleprogram i opcjonalnie zwalnia zarządzane zasoby. (Odziedziczone po WaitHandle)
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Przestarzałe. Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Otwiera określone nazwane zdarzenie synchronizacji, jeśli już istnieje. Jeśli opcje są ustawione tylko dla bieżącego użytkownika, kontrole dostępu obiektu są weryfikowane dla użytkownika wywołującego.
OpenExisting(String)	Otwiera określone nazwane zdarzenie synchronizacji, jeśli już istnieje.
Reset()	Ustawia stan zdarzenia na niepodpisany, powodując zablokowanie wątków.
Set()	Ustawia stan zdarzenia na zasygnalizowany, umożliwiając kontynuowanie co najmniej jednego wątku oczekiwania.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
TryOpenExisting(String, EventWaitHandle)	Otwiera określone nazwane zdarzenie synchronizacji, jeśli już istnieje i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie.
TryOpenExisting(String, NamedWaitHandleOptions, EventWaitHandle)	Otwiera określone nazwane zdarzenie synchronizacji, jeśli już istnieje i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie. Jeśli opcje są ustawione tylko dla bieżącego użytkownika, kontrole dostępu obiektu są weryfikowane dla użytkownika wywołującego.
WaitOne()	Blokuje bieżący wątek, dopóki bieżący nie WaitHandle otrzyma sygnału. (Odziedziczone po WaitHandle)
WaitOne(Int32, Boolean)	Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej liczby całkowitej ze znakiem, aby określić interwał czasu i określić, czy zakończyć domenę synchronizacji przed oczekiwaniem. (Odziedziczone po WaitHandle)
WaitOne(Int32)	Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej liczby całkowitej ze znakiem w celu określenia interwału czasu w milisekundach. (Odziedziczone po WaitHandle)
WaitOne(TimeSpan, Boolean)	Blokuje bieżący wątek, dopóki bieżące wystąpienie nie odbierze sygnału, używając parametru , TimeSpan aby określić interwał czasu i określić, czy należy zamknąć domenę synchronizacji przed oczekiwaniem. (Odziedziczone po WaitHandle)
WaitOne(TimeSpan)	Blokuje bieżący wątek do momentu odebrania sygnału przez bieżące wystąpienie przy użyciu parametru , TimeSpan aby określić interwał czasu. (Odziedziczone po WaitHandle)

Metody rozszerzania

Nazwa	Opis
GetAccessControl(EventWaitHandle)	Zwraca deskryptory zabezpieczeń dla określonego handleelementu .
GetSafeWaitHandle(WaitHandle)	Pobiera bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Ustawia deskryptory zabezpieczeń dla określonego uchwytu oczekiwania zdarzeń.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Ustawia bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkiem.

Zobacz też

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Zarządzane wątkowanie
• Omówienie elementów pierwotnych synchronizacji