ManualResetEvent Osztály

Definíció

Névtér:

System.Threading

Szerelvények:

netstandard.dll, System.Threading.dll

Forrás:

ManualResetEvent.cs

Olyan szálszinkronizálási eseményt jelöl, amelyet a jelzéskor manuálisan kell alaphelyzetbe állítani. Ez az osztály nem örökölhető.

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

public sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

Öröklődés

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Példák

Az alábbi példa bemutatja, hogyan ManualResetEvent működik. A példa egy ManualResetEvent aláíratlan állapottal kezdődik (azaz false a konstruktornak továbbítja). A példa három szálat hoz létre, amelyek mindegyike a metódus meghívásával ManualResetEvent blokkolja a WaitOne folyamatot. Amikor a felhasználó lenyomja az Enter billentyűt, a példa meghívja a Set metódust, amely mindhárom szálat felszabadítja. Ezzel szemben az osztály viselkedése AutoResetEvent , amely egyenként bocsátja ki a szálakat, minden kiadás után automatikusan alaphelyzetbe áll.

Az Enter billentyű ismételt lenyomásával látható, hogy a rendszer a ManualResetEvent metódus meghívásáig Reset a jelzett állapotban marad: A példa két további szálat indít el. Ezek a szálak nem blokkolják, amikor meghívják a metódust WaitOne , hanem a befejezésig futnak.

Az Enter billentyű ismételt lenyomásával a példa meghívja a Reset metódust, és elindít egy újabb szálat, amely blokkolja a hívásokat WaitOne. Nyomja le az Enter billentyűt egy utolsó alkalommal, amikor meghívja Set az utolsó szál kiadását, és a program véget ér.

using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

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

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */

Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

Megjegyzések

ManualResetEventHasználja a , AutoResetEvent, és EventWaitHandle a szál interakció (vagy szál jel). További információ: A szinkronizálási primitívek áttekintése című cikk szál-interakciója vagy jelzési szakasza.

Amikor egy szál olyan tevékenységet kezd el, amelyet a többi szál folytatása előtt végre kell hajtania, meghívja a ManualResetEvent.Reset parancsot , hogy a nem jelzett állapotba kerüljön ManualResetEvent . Ez a szál úgy is felfogható, mint a vezérlő.ManualResetEvent A ManualResetEvent.WaitOne blokkot hívó szálak a jelre várva. Amikor a vezérlőszál befejezi a tevékenységet, meghívja a ManualResetEvent.Set parancsot , hogy jelezze, hogy a várakozó szálak továbbléphetnek. Minden várakozó szál felszabadul.

A jelzést követően a rendszer addig jelzi, ManualResetEvent amíg manuálisan nem állítja vissza a Reset() metódus meghívásával. Vagyis a hívások azonnal visszaérnek WaitOne .

Egy logikai érték konstruktornak való átadásával szabályozhatja a kezdeti állapotot ManualResetEvent : true ha a kezdeti állapot jelzést ad, és false ellenkező esetben.

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

A .NET Framework 2.0-s verziójától kezdve a ManualResetEvent a EventWaitHandle osztályból származik. Az A ManualResetEvent funkcionálisan egyenértékű a EventWaitHandle következővel létrehozottakkal EventResetMode.ManualReset: .

Note

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

A .NET Framework 4.0-s verziójától kezdve a System.Threading.ManualResetEventSlim osztály a ManualResetEvent egyszerű alternatíva.

Konstruktorok

Name	Description
ManualResetEvent(Boolean)	Inicializálja az ManualResetEvent 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