ManualResetEvent Klasse

Definition

Namespace:

System.Threading

Assemblys:

netstandard.dll, 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

Im folgenden Beispiel wird die Funktionsweise veranschaulicht ManualResetEvent . 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 durch Aufrufen der WaitOne Methode blockiert ManualResetEvent werden. Wenn der Benutzer die EINGABETASTE drückt, ruft das Beispiel die Set Methode auf, die alle drei Threads loslässt. Kontrastiert dies mit dem Verhalten der AutoResetEvent Klasse, die Threads nacheinander freigibt, wird nach jeder Version automatisch zurückgesetzt.

Wenn Sie erneut die EINGABETASTE drücken, wird veranschaulicht, dass der ManualResetEvent Verbleib im signalierten Zustand bleibt, 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 erneutes Drücken der EINGABETASTE wird Reset die Methode aufgerufen und ein weiterer Thread gestartet, der beim Aufrufen WaitOneblockiert wird. Drücken Sie die EINGABETASTE ein letztes Mal, Set um den letzten Thread freizugeben, und das Programm endet.

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 "Signalisierung " des Artikels "Übersicht über Synchronisierungsgrundtypen" .

Wenn ein Thread eine Aktivität beginnt, die abgeschlossen werden muss, bevor andere Threads fortgesetzt werden, ruft er ManualResetEvent.Reset auf, um den nicht signalgesteuerten Zustand einzufügen ManualResetEvent . Dieser Thread kann als Steuerung der ManualResetEvent. Threads, die den ManualResetEvent.WaitOne-Block aufrufen und 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 es signalisiert, ManualResetEvent bis es manuell zurückgesetzt wird, indem die Reset() Methode aufgerufen wird. Das heißt, Anrufe, die sofort zurückgegeben werden WaitOne sollen.

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

ManualResetEvent kann auch mit den staticWaitAll Und WaitAny Methoden verwendet werden.

Ab .NET Framework, Version 2.0, wird ManualResetEvent von der klasse EventWaitHandle abgeleitet. A ManualResetEvent entspricht funktional einem EventWaitHandle erstellten mit EventResetMode.ManualReset.

Anmerkung

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

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

Konstruktoren

Name	Beschreibung
ManualResetEvent(Boolean)	Initialisiert eine neue Instanz der ManualResetEvent Klasse mit einem booleschen Wert, der angibt, ob der Anfangszustand signalisiert werden soll.

Felder

Name	Beschreibung
WaitTimeout	Gibt an, dass ein WaitAny(WaitHandle[], Int32, Boolean) Vorgang überschritten wurde, bevor ein Wartepunkt signalisiert wurde. Dieses Feld ist konstant. (Geerbt von WaitHandle)

Eigenschaften

Name	Beschreibung
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

Name	Beschreibung
Close()	Veröffentlicht alle Ressourcen, die von der aktuellen WaitHandle. (Geerbt von WaitHandle)
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 von den WaitHandleverwalteten Ressourcen verwendet werden, und optional die verwalteten Ressourcen freigegeben. (Geerbt von WaitHandle)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
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)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
WaitOne()	Blockiert den aktuellen Thread, bis der aktuelle WaitHandle Thread ein Signal empfängt. (Geerbt von WaitHandle)
WaitOne(Int32, Boolean)	Blockiert den aktuellen Thread, bis der aktuelle WaitHandle Thread ein Signal empfängt, wobei eine 32-Bit-ganzzahl mit Vorzeichen verwendet wird, um das Zeitintervall anzugeben und anzugeben, ob die Synchronisierungsdomäne vor dem Warten beendet werden soll. (Geerbt von WaitHandle)
WaitOne(Int32)	Blockiert den aktuellen Thread, bis der aktuelle WaitHandle Thread ein Signal empfängt, wobei eine 32-Bit-ganzzahl mit Vorzeichen verwendet wird, um das Zeitintervall in Millisekunden anzugeben. (Geerbt von WaitHandle)
WaitOne(TimeSpan, Boolean)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei ein TimeSpan Zeitintervall angegeben und angegeben wird, 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 Zeitintervall angegeben wird. (Geerbt von WaitHandle)

Erweiterungsmethoden

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

Threadsicherheit

Diese Klasse ist threadsicher.

Weitere Informationen

• WaitHandle
• Verwaltetes Thread-Management
• Übersicht über Synchronisierungsgrundtypen