AutoResetEvent Osztály

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.dll

Forrás:

AutoResetEvent.cs

Olyan szálszinkronizálási eseményt jelöl, amely a jelzéskor egyetlen várakozási szálat bocsát ki, majd automatikusan alaphelyzetbe állítja. Ez az osztály nem örökölhető.

public ref class AutoResetEvent sealed : System::Threading::EventWaitHandle

public sealed class AutoResetEvent : System.Threading.EventWaitHandle

type AutoResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class AutoResetEvent
Inherits EventWaitHandle

Öröklődés

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

AutoResetEvent

Példák

Az alábbi példa bemutatja, hogyan lehet AutoResetEvent egyszerre egy szálat felszabadítani a metódus meghívásával Set (az alaposztályon) minden alkalommal, amikor a felhasználó lenyomja az Enter billentyűt. A példa három szálat indít el, amelyek a jelzett állapotban létrehozott szálra AutoResetEvent várnak. Az első szál azonnal felszabadul, mert az AutoResetEvent már a jelzett állapotban van. Ez alaphelyzetbe állítja a AutoResetEvent nem jelzett állapotot, így a további szálak blokkolva lesznek. A blokkolt szálak csak akkor szabadulnak fel, ha a felhasználó az Enter billentyű lenyomásával egyenként fel nem oldja őket.

Miután a szálak ki lettek engedve az elsőből AutoResetEvent, várnak egy másikra AutoResetEvent , amely nem jeles állapotban lett létrehozva. Mindhárom szál blokkolva van, ezért a Set metódust háromszor kell meghívni az összes felszabadításához.

using System;
using System.Threading;

// Visual Studio: Replace the default class in a Console project with 
//                the following class.
class Example
{
    private static AutoResetEvent event_1 = new AutoResetEvent(true);
    private static AutoResetEvent event_2 = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Press Enter to create three threads and start them.\r\n" +
                          "The threads wait on AutoResetEvent #1, which was created\r\n" +
                          "in the signaled state, so the first thread is released.\r\n" +
                          "This puts AutoResetEvent #1 into the unsignaled state.");
        Console.ReadLine();
            
        for (int i = 1; i < 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }
        Thread.Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine("Press Enter to release another thread.");
            Console.ReadLine();
            event_1.Set();
            Thread.Sleep(250);
        }

        Console.WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Press Enter to release a thread.");
            Console.ReadLine();
            event_2.Set();
            Thread.Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console.Readline();
    }

    static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console.WriteLine("{0} ends.", name);
    }
}

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */

Imports System.Threading

' Visual Studio: Replace the default class in a Console project with 
'                the following class.
Class Example

    Private Shared event_1 As New AutoResetEvent(True)
    Private Shared event_2 As New AutoResetEvent(False)

    <MTAThread()> _
    Shared Sub Main()
    
        Console.WriteLine("Press Enter to create three threads and start them." & vbCrLf & _
                          "The threads wait on AutoResetEvent #1, which was created" & vbCrLf & _
                          "in the signaled state, so the first thread is released." & vbCrLf & _
                          "This puts AutoResetEvent #1 into the unsignaled state.")
        Console.ReadLine()
            
        For i As Integer = 1 To 3
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next
        Thread.Sleep(250)

        For i As Integer = 1 To 2
            Console.WriteLine("Press Enter to release another thread.")
            Console.ReadLine()

            event_1.Set()
            Thread.Sleep(250)
        Next

        Console.WriteLine(vbCrLf & "All threads are now waiting on AutoResetEvent #2.")
        For i As Integer = 1 To 3
            Console.WriteLine("Press Enter to release a thread.")
            Console.ReadLine()

            event_2.Set()
            Thread.Sleep(250)
        Next

        ' Visual Studio: Uncomment the following line.
        'Console.Readline()
    End Sub

    Shared Sub ThreadProc()
    
        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name)
        event_1.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name)

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name)
        event_2.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name)

        Console.WriteLine("{0} ends.", name)
    End Sub
End Class

' This example produces output similar to the following:
'
'Press Enter to create three threads and start them.
'The threads wait on AutoResetEvent #1, which was created
'in the signaled state, so the first thread is released.
'This puts AutoResetEvent #1 into the unsignaled state.
'
'Thread_1 waits on AutoResetEvent #1.
'Thread_1 is released from AutoResetEvent #1.
'Thread_1 waits on AutoResetEvent #2.
'Thread_3 waits on AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #1.
'Press Enter to release another thread.
'
'Thread_3 is released from AutoResetEvent #1.
'Thread_3 waits on AutoResetEvent #2.
'Press Enter to release another thread.
'
'Thread_2 is released from AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #2.
'
'All threads are now waiting on AutoResetEvent #2.
'Press Enter to release a thread.
'
'Thread_2 is released from AutoResetEvent #2.
'Thread_2 ends.
'Press Enter to release a thread.
'
'Thread_1 is released from AutoResetEvent #2.
'Thread_1 ends.
'Press Enter to release a thread.
'
'Thread_3 is released from AutoResetEvent #2.
'Thread_3 ends.

Megjegyzések

AutoResetEventHasználja a , ManualResetEvent, és EventWaitHandle a szál interakció (vagy szál jel). További információ: Szál interakciója.

A szál az AutoResetEvent.WaitOne hívásával vár a jelre. Ha a AutoResetEvent szál nem jelzett állapotban van, a szál addig blokkolódik, amíg az AutoResetEvent.Set meghívása meg nem történik. Jelek Set hívása AutoResetEvent várakozó szál felszabadításához. AutoResetEvent a rendszer a hívásig vagy egyetlen várakozási szál felszabadításáig Reset jelzi, amikor a rendszer automatikusan visszaáll a nem jelzett állapotba.

Ha egyetlen szál sem várakozik, amikor a AutoResetEvent jelzett állapotba kerül, az állapot addig lesz jelezve, amíg egy szál nem figyeli a jelet (hívással WaitOne). Ez a szál nem blokkolja a következőt: a AutoResetEvent rendszer azonnal felszabadítja a szálat, és visszaáll a nem jelzett állapotba.

Important

Nincs garancia arra, hogy a Set metódus minden hívása felszabadít egy szálat. Ha két hívás túl közel van egymáshoz, így a második hívás egy szál felszabadítása előtt történik, csak egy szál lesz felszabadítva. Mintha a második hívás nem történt volna meg. Ha a rendszer akkor is meghívja, ha Set nincsenek várakozó szálak, és a AutoResetEvent rendszer már jelzi, a hívásnak nincs hatása.

Egy logikai érték konstruktornak való átadásával szabályozhatja a kezdeti állapotot AutoResetEvent : true ha a kezdeti állapot jelzésre kerül, és false ellenkező esetben.

AutoResetEventa metódusokkal és static a WaitAllWaitAny módszerekkel is használható.

AutoResetEvent az osztályból EventWaitHandle származik. Az an AutoResetEvent függvény funkcionálisan egyenértékű a EventWaitHandle következővel létrehozottakkal EventResetMode.AutoReset: .

Note

Az osztálytól AutoResetEvent eltérően az EventWaitHandle osztály hozzáférést biztosít a nevesített rendszerszinkronizálási eseményekhez.

Important

Ez a típus implementálja a IDisposable felületet. Ha befejezte a típus használatát, közvetlenül (a metódus meghívásával) vagy közvetetten (például using a C#-ban) kell elhelyeznie Dispose a típust. További információ: Az IDisposable-t megvalósító objektum használata.

Konstruktorok

Name	Description
AutoResetEvent(Boolean)	Inicializálja az AutoResetEvent osztály új példányát logikai értékkel, amely jelzi, hogy a kezdeti állapot jelzésre van-e állítva.

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)
Reset()	Az esemény állapotát nem hozzárendelt állapotra állítja, így a szálak blokkolva lesznek. (Öröklődés forrása EventWaitHandle)
Set()	Beállítja az esemény állapotát jelzésre, így egy vagy több várakozó szál továbbhaladhat. (Öröklődés forrása EventWaitHandle)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
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 az osztály szálbiztos.

Lásd még

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