EventWaitHandle Osztály

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.dll

Forrás:

EventWaitHandle.cs

Szálszinkronizálási eseményt jelöl.

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

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Öröklődés

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Származtatott

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Példák

Az alábbi példakód a metódus túlterhelésével SignalAndWait(WaitHandle, WaitHandle) teszi lehetővé, hogy a főszál jelezzen egy blokkolt szálat, majd várja meg, amíg a szál befejez egy feladatot.

A példa öt szálat indít el, és lehetővé teszi számukra, hogy letiltsák a EventWaitHandle jelölővel létrehozott elemeketEventResetMode.AutoReset, majd minden alkalommal, amikor a felhasználó lenyomja az Enter billentyűt, kiad egy szálat. A példa ezután további öt szálat várólistára állít, és az összeset egy EventWaitHandle jelölővel EventResetMode.ManualReset létrehozott üzenettel oldja fel.

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

Megjegyzések

Az EventWaitHandle osztály lehetővé teszi, hogy a szálak jelzéssel kommunikáljanak egymással. Általában egy vagy több szál blokkolja a metódust EventWaitHandle , amíg egy feloldott szál nem hívja meg a Set metódust, és felszabadít egy vagy több blokkolt szálat. A szálak jelezhetnek egy EventWaitHandle, majd blokkolhatják azt a static meghívásával (Shared Visual Basic) WaitHandle.SignalAndWait metódus meghívásával.

Note

Az EventWaitHandle osztály hozzáférést biztosít a névvel ellátott rendszerszinkronizálási eseményekhez.

A jelzést kapott viselkedés EventWaitHandle az alaphelyzetbe állítási módtól függ. A EventWaitHandle jelölővel EventResetMode.AutoReset létrehozott elemek automatikusan visszaállnak a jelzéskor, miután egyetlen várakozási szálat szabadított fel. A EventWaitHandle jelzővel létrehozott EventResetMode.ManualReset addig van jelezve, amíg a Reset metódusát meg nem hívják.

Az automatikus visszaállítási események kizárólagos hozzáférést biztosítanak egy erőforráshoz. Ha egy automatikus visszaállítási eseményt jelez, amikor nem várakoznak szálak, az jelzett marad egészen addig, amíg egy szál meg nem kísérli a várakozást. Az esemény felszabadítja a szálat, és azonnal alaphelyzetbe állítja, blokkolva a további szálakat.

A manuális visszaállítási események olyanok, mint a kapuk. Ha az esemény nincs jelezve, a rajta várakozó szálak blokkolni fognak. Az esemény jelzésekor az összes várakozási szál felszabadul, és az esemény a metódus meghívásáig Reset (azaz a későbbi várakozások nem blokkolva) lesznek jelezve. A manuális visszaállítási események akkor hasznosak, ha egy szálnak el kell végeznie egy tevékenységet, mielőtt a többi szál továbbléphet.

EventWaitHandle objektumok használhatók a static(Shared Visual Basic) WaitHandle.WaitAll és WaitHandle.WaitAny metódusokkal.

További információ: A szinkronizálási primitívek áttekintése című cikk szál-interakciója vagy jelzési szakasza.

Figyelmeztetés

Alapértelmezés szerint a névvel ellátott esemény nem korlátozódik az azt létrehozó felhasználóra. Előfordulhat, hogy más felhasználók is megnyithatják és használhatják az eseményt, beleértve az esemény helytelen beállításával vagy alaphelyzetbe állításával való beavatkozást is. Az adott felhasználók hozzáférésének korlátozásához használhat konstruktor túlterhelést, vagy EventWaitHandleAcl átadhat egy eseményt EventWaitHandleSecurity a nevesített esemény létrehozásakor. Ne használjon elnevezett eseményeket hozzáférési korlátozások nélkül azokra a rendszerekre, amelyeken esetleg nem megbízható felhasználók futtatnak kódot.

Konstruktorok

Name	Description
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Inicializálja az EventWaitHandle osztály egy új példányát, amely megadja, hogy a várakozási fogópont először jelezve legyen, ha a hívás eredményeként jött létre, automatikusan vagy manuálisan visszaállítja-e, egy rendszerszinkronizálási esemény nevét, valamint egy logikai változót, amelynek értéke a hívás után jelzi, hogy a névvel ellátott rendszeresemény létrejött-e.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions, Boolean)	Inicializálja az EventWaitHandle osztály egy új példányát, amely megadja, hogy a várakozási fogópont először jelezve legyen, ha a hívás eredményeként jött létre, automatikusan vagy manuálisan alaphelyzetbe áll-e, a rendszerszinkronizálási esemény neve, a felhasználói hatókör és a munkamenet-hatókör hozzáférésének beállítására szolgáló beállítások, valamint egy logikai változó, amelynek értéke a hívás után jelzi, hogy a névvel ellátott rendszeresemény létrejött-e.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions)	Inicializálja az EventWaitHandle osztály egy új példányát, megadva, hogy a hívás eredményeként létrehozott várakozási leíró kezdetben jelezve legyen-e, automatikusan vagy manuálisan alaphelyzetbe áll-e, a rendszerszinkronizálási esemény neve, valamint a felhasználói hatókör és a munkamenet-hatókör hozzáférésének beállítási lehetőségei.
EventWaitHandle(Boolean, EventResetMode, String)	Inicializálja az EventWaitHandle osztály egy új példányát, megadva, hogy a várakozási fogópont először jelezve legyen, ha a hívás eredményeként jött létre, automatikusan vagy manuálisan alaphelyzetbe áll-e, valamint egy rendszerszinkronizálási esemény nevét.
EventWaitHandle(Boolean, EventResetMode)	Inicializálja az EventWaitHandle osztály új példányát, megadva, hogy a várakozási fogópont kezdetben jelezve van-e, és hogy az automatikusan vagy manuálisan alaphelyzetbe áll-e.

Mezők

Name	Description
WaitTimeout	Azt jelzi, hogy egy WaitAny(WaitHandle[], Int32, Boolean) művelet időtúllépést jelzett a várakozási fogópontok jelzése előtt. Ez a mező állandó. (Öröklődés forrása WaitHandle)

Tulajdonságok

Name	Description
Handle	Elavult. Lekéri vagy beállítja a natív operációsrendszer-leírót. (Öröklődés forrása WaitHandle)
SafeWaitHandle	Lekéri vagy beállítja a natív operációsrendszer-leírót. (Öröklődés forrása WaitHandle)

Metódusok

Name	Description
Close()	Az aktuális WaitHandleerőforrás összes erőforrását felszabadítja. (Öröklődés forrása WaitHandle)
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja WaitHandle . (Öröklődés forrása WaitHandle)
Dispose(Boolean)	Ha egy származtatott osztályban felül van bírálva, kiadja a nem felügyelt erőforrásokat, amelyeket a WaitHandlerendszer használ, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása WaitHandle)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Elavult. Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Elavult. Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Megnyitja a megadott elnevezett szinkronizálási eseményt, ha már létezik. Ha a beállítások csak az aktuális felhasználóra vannak beállítva, a rendszer ellenőrzi az objektum hozzáférés-vezérlését a hívó felhasználó számára.
OpenExisting(String)	Megnyitja a megadott elnevezett szinkronizálási eseményt, ha már létezik.
Reset()	Az esemény állapotát nem hozzárendelt állapotra állítja, így a szálak blokkolva lesznek.
Set()	Beállítja az esemény állapotát jelzésre, így egy vagy több várakozó szál továbbhaladhat.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
TryOpenExisting(String, EventWaitHandle)	Megnyitja a megadott elnevezett szinkronizálási eseményt, ha már létezik, és visszaad egy értéket, amely jelzi, hogy a művelet sikeres volt-e.
TryOpenExisting(String, NamedWaitHandleOptions, EventWaitHandle)	Megnyitja a megadott elnevezett szinkronizálási eseményt, ha már létezik, és visszaad egy értéket, amely jelzi, hogy a művelet sikeres volt-e. Ha a beállítások csak az aktuális felhasználóra vannak beállítva, a rendszer ellenőrzi az objektum hozzáférés-vezérlését a hívó felhasználó számára.
WaitOne()	Blokkolja az aktuális szálat, amíg az áram WaitHandle nem kap jelet. (Öröklődés forrása WaitHandle)
WaitOne(Int32, Boolean)	Blokkolja az aktuális szálat, amíg az aktuális WaitHandle nem kap jelet, egy 32 bites aláírt egész számmal adja meg az időintervallumot, és adja meg, hogy a várakozás előtt ki kell-e lépnie a szinkronizálási tartományból. (Öröklődés forrása WaitHandle)
WaitOne(Int32)	Blokkolja az aktuális szálat, amíg az aktuális WaitHandle nem kap jelet, egy 32 bites aláírt egész számmal adja meg az időintervallumot ezredmásodpercben. (Öröklődés forrása WaitHandle)
WaitOne(TimeSpan, Boolean)	Letiltja az aktuális szálat, amíg az aktuális példány nem kap jelet, az időintervallum megadásához és annak megadásához, TimeSpan hogy a várakozás előtt kilépjen-e a szinkronizálási tartományból. (Öröklődés forrása WaitHandle)
WaitOne(TimeSpan)	Letiltja az aktuális szálat, amíg az aktuális példány nem kap jelet az TimeSpan időintervallum megadásához. (Öröklődés forrása WaitHandle)

Bővítő metódusok

Name	Description
GetAccessControl(EventWaitHandle)	A megadott handlebiztonsági leírókat adja vissza.
GetSafeWaitHandle(WaitHandle)	Lekéri a natív operációs rendszer várakozási fogópontjának biztonságos fogópontját.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Beállítja a megadott esemény várakozási leírójának biztonsági leíróit.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Beállít egy biztonságos fogópontot a natív operációs rendszer várakozási fogópontjához.

Szálbiztonság

Ez a típus szálbiztos.

Lásd még

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• felügyelt szálkezelés
• A szinkronizálási primitívek áttekintése