ManualResetEvent Klasse

Definition

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

public ref class ManualResetEvent sealed : System::Threading::EventWaitHandle
public ref class ManualResetEvent sealed : System::Threading::WaitHandle
public sealed class ManualResetEvent : System.Threading.EventWaitHandle
public sealed class ManualResetEvent : System.Threading.WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ManualResetEvent : System.Threading.EventWaitHandle
type ManualResetEvent = class
    inherit EventWaitHandle
type ManualResetEvent = class
    inherit WaitHandle
[<System.Runtime.InteropServices.ComVisible(true)>]
type ManualResetEvent = class
    inherit EventWaitHandle
Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle
Public NotInheritable Class ManualResetEvent
Inherits WaitHandle
Vererbung
ManualResetEvent
Vererbung
Vererbung
Attribute

Beispiele

Im folgenden Beispiel wird die Funktionsweise ManualResetEvent veranschaulicht. Das Beispiel beginnt mit einem im nicht signalisiertem Zustand (d. h. ManualResetEvent wird an den Konstruktor false übergeben). Im Beispiel werden drei Threads erstellt, von denen jeder durch Aufrufen der -Methode für ManualResetEvent WaitOne blockiert. Wenn der Benutzer die EINGABETASTE drückt, ruft das Beispiel die -Methode Set auf, die alle drei Threads freilässt. Vergleichen Sie dies mit dem Verhalten der -Klasse, die Threads nacheinander freilässt und nach jedem AutoResetEvent Release automatisch zurück setzt.

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

Wenn Sie die EINGABETASTE erneut drücken, ruft das Beispiel die -Methode auf und startet einen anderen Thread, der Reset blockiert, wenn aufgerufen WaitOne wird. Wenn Sie die EINGABETASTE ein letztes Mal drücken, wird aufgerufen, um den letzten Thread frei Set zu geben, und das Programm wird beendet.

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 , und für die AutoResetEvent EventWaitHandle Threadinteraktion (oder Threadsignalisierung). Weitere Informationen finden Sie im Abschnitt Threadinteraktion oder Signalisierung des Artikels Übersicht über Synchronisierungsprimitiven.

Wenn ein Thread eine Aktivität startet, die abgeschlossen werden muss, bevor andere Threads fortgesetzt werden, ruft er ManualResetEvent.Reset auf, um in den nicht ManualResetEvent signalisierten Zustand zu setzen. Dieser Thread kann als Steuerung von bezeichnet ManualResetEvent werden. Threads, die den ManualResetEvent.WaitOne-Block aufrufen, warten auf das Signal. Wenn der steuernde Thread die Aktivität ab schließt, ruft er ManualResetEvent.Set auf, um zu signalisieren, dass die wartenden Threads fortgesetzt werden können. Alle wartenden Threads werden freigegeben.

Nachdem sie signalisiert wurde, bleibt signalisiert, bis sie manuell zurückgesetzt ManualResetEvent wird, indem die -Methode Reset() aufruft. Das bedeutet, dass aufruft, WaitOne sofort zurückzukehren.

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

ManualResetEvent kann auch mit den Methoden static WaitAll und verwendet WaitAny werden.

Ab der .NET Framework Version 2.0 wird ManualResetEvent von der -Klasse EventWaitHandle ableiten. Ein ManualResetEvent ist funktionell äquivalent zu einem , EventWaitHandle der mit erstellt EventResetMode.ManualReset wurde.

Hinweis

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

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

Konstruktoren

ManualResetEvent(Boolean)

Initialisiert eine neue Instanz der ManualResetEvent-Klasse mit einem booleschen Wert, der angibt, ob der anfängliche Zustand auf signalisiert festgelegt werden soll.

Felder

WaitTimeout

Gibt an, dass ein Timeout für einen WaitAny(WaitHandle[], Int32, Boolean)-Vorgang überschritten wurde, bevor ein Signal an eines der WaitHandles gesendet wurde. Dieses Feld ist konstant.

(Geerbt von WaitHandle)

Eigenschaften

Handle
Veraltet.
Veraltet.

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.

(Geerbt von WaitHandle)
SafeWaitHandle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.

(Geerbt von WaitHandle)

Methoden

Close()

Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei.

(Geerbt von WaitHandle)
CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei.

(Geerbt von WaitHandle)
Dispose(Boolean)

Gibt beim Überschreiben in einer abgeleiteten Klasse die von WaitHandle verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von WaitHandle)
Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetAccessControl()

Ruft ein EventWaitHandleSecurity-Objekt ab, das die Zugriffssteuerungssicherheit für das benannte Systemereignis darstellt, das durch das aktuelle EventWaitHandle-Objekt dargestellt wird.

(Geerbt von EventWaitHandle)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.

(Geerbt von MarshalByRefObject)
Reset()

Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden.

Reset()

Legt den Zustand des Ereignisses auf nicht signalisiert fest, sodass Threads blockiert werden.

(Geerbt von EventWaitHandle)
Set()

Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren.

Set()

Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren.

(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 das aktuelle WaitHandle ein Signal empfängt.

(Geerbt von WaitHandle)
WaitOne(Int32)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird.

(Geerbt von WaitHandle)
WaitOne(Int32, Boolean)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.

(Geerbt von WaitHandle)
WaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.

(Geerbt von WaitHandle)
WaitOne(TimeSpan, Boolean)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.

(Geerbt von WaitHandle)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht.

Gibt alle vom WaitHandle verwendeten Ressourcen frei.

(Geerbt von WaitHandle)

Erweiterungsmethoden

GetAccessControl(EventWaitHandle)

Gibt die Sicherheitsbeschreibungen für das angegebene handle zurück.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Legt die Sicherheitsbeschreibungen für das angegebene Ereigniswartehandle fest.

GetSafeWaitHandle(WaitHandle)

Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.

Gilt für

Threadsicherheit

Diese Klasse ist threadsicher.

Siehe auch