ManualResetEvent Klasse

Definition

Namespace:

System.Threading

Assembly:

System.Threading.dll

Quelle:

ManualResetEvent.cs

Stellt ein Threadsynchronisierungsereignis dar, das bei signalisierter Signalisierung manuell zurückgesetzt werden muss. Diese Klasse kann nicht geerbt werden.

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

Vererbung

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Beispiele

Das folgende Beispiel veranschaulicht, wie ManualResetEvent funktioniert. Das Beispiel beginnt mit einem ManualResetEvent im nicht signalierten Zustand (d. a. false wird an den Konstruktor übergeben). Im Beispiel werden drei Threads erstellt, die jeweils für die ManualResetEvent durch Aufrufen der WaitOne-Methode blockiert werden. Wenn der Benutzer die EINGABETASTE taste drückt, ruft das Beispiel die Set-Methode auf, die alle drei Threads loslässt. Kontrastieren Sie dies mit dem Verhalten der AutoResetEvent-Klasse, die Threads nach jeder Veröffentlichung automatisch zurücksetzt.

Durch Drücken der EINGABETASTE Taste wird erneut veranschaulicht, dass die ManualResetEvent im signalierten Zustand verbleibt, bis die Reset-Methode aufgerufen wird: Im Beispiel werden zwei weitere Threads gestartet. Diese Threads blockieren nicht, wenn sie die WaitOne-Methode aufrufen, sondern zum Abschluss ausgeführt werden.

Durch drücken der EINGABETASTE Taste wird das Beispiel erneut die Reset-Methode aufrufen und einen weiteren Thread starten, der beim Aufrufen WaitOneblockiert wird. Durch Drücken der EINGABETASTE taste ein letztes Mal Set aufruft, um den letzten Thread freizugeben, und das Programm endet.

using namespace System;
using namespace System::Threading;

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

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine(name + " starts and calls mre->WaitOne()");

        mre->WaitOne();

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

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

        for(int i = 0; i <=2 ; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(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 = gcnew Thread(gcnew ThreadStart(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 = gcnew Thread(gcnew ThreadStart(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();
    }
};

int main()
{
   Example::Demo();
}

/* 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_1 ends.
Thread_0 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.
 */

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.

Hinweise

Sie verwenden ManualResetEvent, AutoResetEventund EventWaitHandle für threadinteraktion (oder Threadsignalisierung). Weitere Informationen finden Sie im Abschnitt Threadinteraktion oder signalisieren Abschnitt des Übersicht über Synchronisierungsgrundtypen Artikel.

Wenn ein Thread eine Aktivität beginnt, die abgeschlossen werden muss, bevor andere Threads fortgesetzt werden, wird ManualResetEvent.Reset aufgerufen, um ManualResetEvent in den nicht signalgesteuerten Zustand zu versetzen. Dieser Thread kann als Steuerung der ManualResetEventbetrachtet werden. Threads, die ManualResetEvent.WaitOne Block aufrufen, auf das Signal warten. Wenn der steuernde Thread die Aktivität abgeschlossen hat, ruft er ManualResetEvent.Set auf, um zu signalisieren, dass die Wartethreads fortgesetzt werden können. Alle wartenden Threads werden freigegeben.

Nachdem es signalisiert wurde, bleibt ManualResetEvent signalisiert, bis es manuell zurückgesetzt wird, indem die Reset()-Methode aufgerufen wird. Das heißt, Anrufe an WaitOne sofort zurückgeben.

Sie können den Anfangszustand eines ManualResetEvent steuern, indem Sie einen booleschen Wert an den Konstruktor übergeben: true, wenn der Anfangszustand signalisiert wird, und false andernfalls.

ManualResetEvent können auch mit den methoden staticWaitAll und WaitAny verwendet werden.

Ab .NET Framework, Version 2.0, wird ManualResetEvent von der EventWaitHandle-Klasse abgeleitet. Ein ManualResetEvent entspricht funktional einem mit EventResetMode.ManualReseterstellten EventWaitHandle.

Anmerkung

Im Gegensatz zur ManualResetEvent Klasse bietet die EventWaitHandle Klasse Zugriff auf benannte Systemsynchronisierungsereignisse.

Ab .NET Framework, Version 4.0, ist die System.Threading.ManualResetEventSlim-Klasse eine einfache Alternative zu ManualResetEvent.

Konstruktoren

ManualResetEvent(Boolean)

Initialisiert eine neue Instanz der ManualResetEvent Klasse mit einem booleschen Wert, der angibt, ob der anfangs signalisierte Zustand festgelegt werden soll.

Felder

WaitTimeout

Gibt an, dass ein WaitAny(WaitHandle[], Int32, Boolean) Vorgang überschritten wurde, bevor eine der Warteziehpunkte signalisiert wurde. Dieses Feld ist konstant. (Geerbt von WaitHandle)

Eigenschaften

Handle	Veraltet. Dient zum Abrufen oder Festlegen des systemeigenen Betriebssystemhandles. (Geerbt von WaitHandle)
SafeWaitHandle	Dient zum Abrufen oder Festlegen des systemeigenen Betriebssystemhandles. (Geerbt von WaitHandle)

Methoden

Close()	Veröffentlicht alle Ressourcen, die vom aktuellen WaitHandlegehalten werden. (Geerbt von WaitHandle)
CreateObjRef(Type)	Erstellt ein Objekt, das alle relevanten Informationen enthält, die zum Generieren eines Proxys erforderlich sind, der für die Kommunikation mit einem Remoteobjekt verwendet wird. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle Ressourcen frei, die von der aktuellen Instanz der WaitHandle Klasse verwendet werden. (Geerbt von WaitHandle)
Dispose(Boolean)	Wenn sie in einer abgeleiteten Klasse überschrieben werden, werden die nicht verwalteten Ressourcen freigegeben, die vom WaitHandleverwendet werden, und optional die verwalteten Ressourcen freigegeben. (Geerbt von WaitHandle)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetAccessControl()	Ruft ein EventWaitHandleSecurity -Objekt, das die Zugriffssteuerungssicherheit für das benannte Systemereignis darstellt, dargestellt durch das aktuelle EventWaitHandle -Objekt. (Geerbt von EventWaitHandle)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
Reset()	Legt den Status des Ereignisses auf "nicht signaliert" fest, wodurch Threads blockiert werden. (Geerbt von EventWaitHandle)
Set()	Legt den Status des Ereignisses fest, das signalisiert wird, sodass ein oder mehrere Wartethreads fortgesetzt werden können. (Geerbt von EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Legt die Zugriffssteuerungssicherheit für ein benanntes Systemereignis fest. (Geerbt von EventWaitHandle)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
WaitOne()	Blockiert den aktuellen Thread, bis die aktuelle WaitHandle ein Signal empfängt. (Geerbt von WaitHandle)
WaitOne(Int32)	Blockiert den aktuellen Thread, bis die aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-ganzzahl mit Vorzeichen verwendet wird, um das Zeitintervall in Millisekunden anzugeben. (Geerbt von WaitHandle)
WaitOne(Int32, Boolean)	Blockiert den aktuellen Thread, bis die aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-ganzzahl mit Vorzeichen verwendet wird, um das Zeitintervall anzugeben und anzugeben, ob die Synchronisierungsdomäne vor der Wartezeit beendet werden soll. (Geerbt von WaitHandle)
WaitOne(TimeSpan)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei ein TimeSpan verwendet wird, um das Zeitintervall anzugeben. (Geerbt von WaitHandle)
WaitOne(TimeSpan, Boolean)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei ein TimeSpan verwendet wird, um das Zeitintervall anzugeben und anzugeben, ob die Synchronisierungsdomäne vor der Wartezeit beendet werden soll. (Geerbt von WaitHandle)

Erweiterungsmethoden

GetAccessControl(EventWaitHandle)	Gibt die Sicherheitsbeschreibungen für die angegebene handlezurück.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Legt die Sicherheitsdeskriptoren für das angegebene Ereigniswartehandle fest.
GetSafeWaitHandle(WaitHandle)	Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait Handle ab.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Legt einen sicheren Handle für ein systemeigenes Betriebssystem-Wait Handle fest.

Threadsicherheit

Diese Klasse ist threadsicher.

Weitere Informationen

• WaitHandle
• verwalteten Threading-
• Übersicht über Synchronisierungsgrundtypen