ManualResetEvent Klasse

Definition

Stellt ein Threadsynchronisierungsereignis dar; muss bei Signalisierung manuell zurückgesetzt werden.Represents a thread synchronization event that, when signaled, must be reset manually. Diese Klasse kann nicht vererbt werden.This class cannot be inherited.

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

Beispiele

Im folgenden Beispiel wird veranschaulicht ManualResetEvent , wie funktioniert.The following example demonstrates how ManualResetEvent works. Das Beispiel beginnt mit einem ManualResetEvent im nicht signalisierten Zustand (d. h false ., wird an den-Konstruktor übergeben).The example starts with a ManualResetEvent in the unsignaled state (that is, false is passed to the constructor). Im Beispiel werden drei Threads erstellt, die jeweils ManualResetEvent durch WaitOne Aufrufen der-Methode blockiert werden.The example creates three threads, each of which blocks on the ManualResetEvent by calling its WaitOne method. Wenn der Benutzer die Eingabe Taste drückt, ruft das Beispiel die Set -Methode auf, die alle drei Threads freigibt.When the user presses the Enter key, the example calls the Set method, which releases all three threads. Vergleichen Sie dies mit dem Verhalten AutoResetEvent der-Klasse, die Threads nacheinander freigibt und nach jeder Version automatisch zurückgesetzt wird.Contrast this with the behavior of the AutoResetEvent class, which releases threads one at a time, resetting automatically after each release.

Wenn Sie die Eingabe Taste erneut drücken, ManualResetEvent wird veranschaulicht, dass die im signalisierten Zustand verbleibt, bis Ihre Reset -Methode aufgerufen wird: Im Beispiel werden zwei weitere Threads gestartet.Pressing the Enter key again demonstrates that the ManualResetEvent remains in the signaled state until its Reset method is called: The example starts two more threads. Diese Threads werden nicht blockiert, wenn Sie die WaitOne -Methode aufzurufen, sondern bis zum Abschluss ausgeführt werden.These threads do not block when they call the WaitOne method, but instead run to completion.

Das erneute Drücken der Eingabe Taste bewirkt, dass das Beispiel Reset die-Methode aufruft und einen weiteren Thread startet, der beim Aufrufen WaitOnevon blockiert wird.Pressing the Enter key again causes the example to call the Reset method and to start one more thread, which blocks when it calls WaitOne. Durch Drücken der Eingabe Taste einmal wird aufgerufen Set , um den letzten Thread freizugeben, und das Programm wird beendet.Pressing the Enter key one final time calls Set to release the last thread, and the program ends.

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 die Thread Interaktion (oder Thread Signalisierung).You use ManualResetEvent, AutoResetEvent, and EventWaitHandle for thread interaction (or thread signaling). Weitere Informationen finden Sie im Artikel Thread Interaktion oder Signalisierung im Artikel Übersicht über Synchronisierungs primitive .For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

Wenn ein Thread eine Aktivität startet, die vor dem fortsetzen anderer Threads beendet werden muss, wird ManualResetEvent. Reset aufgerufen, um ihn in den nicht signalisierten Zustand zu versetzen ManualResetEvent .When a thread begins an activity that must complete before other threads proceed, it calls ManualResetEvent.Reset to put ManualResetEvent in the non-signaled state. Dieser Thread kann sich als Steuern ManualResetEventvon vorstellen.This thread can be thought of as controlling the ManualResetEvent. Threads, die den Block manualrel tevent. WaitOne aufzurufen und auf das Signal warten.Threads that call ManualResetEvent.WaitOne block, awaiting the signal. Wenn der steuernde Thread die Aktivität abschließt, wird ManualResetEvent. Set aufgerufen, um zu signalisieren, dass die wartenden Threads fortfahren können.When the controlling thread completes the activity, it calls ManualResetEvent.Set to signal that the waiting threads can proceed. Alle wartenden Threads werden freigegeben.All waiting threads are released.

Nachdem Sie signalisiert wurde, bleibt ManualResetEvent signalisiert, bis Sie manuell durch Aufrufen der Reset() -Methode zurückgesetzt wird.Once it has been signaled, ManualResetEvent remains signaled until it is manually reset by calling the Reset() method. Das heißt, Aufrufe von WaitOne werden sofort zurückgegeben.That is, calls to WaitOne return immediately.

Sie können den Anfangszustand eines ManualResetEvent steuern, indem Sie einen booleschen Wert an den Konstruktor übergeben: true , wenn der Anfangszustand signalisiert ist false , und andernfalls.You can control the initial state of a ManualResetEvent by passing a Boolean value to the constructor: true if the initial state is signaled, and false otherwise.

ManualResetEventkann auch mit der-Methode static und WaitAny der WaitAll -Methode verwendet werden.ManualResetEvent can also be used with the static WaitAll and WaitAny methods.

Beginnend mit der .NET Framework Version 2,0, ManualResetEvent wird von der EventWaitHandle -Klasse abgeleitet.Beginning with the .NET Framework version 2.0, ManualResetEvent derives from the EventWaitHandle class. Eine ManualResetEvent ist funktional äquivalent zu einer EventWaitHandle , die EventResetMode.ManualResetmit erstellt wurde.A ManualResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.ManualReset.

Hinweis

Im Gegensatz ManualResetEvent zur-Klasse EventWaitHandle bietet die-Klasse Zugriff auf benannte System Synchronisierungs Ereignisse.Unlike the ManualResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

Ab der .NET Framework Version 4,0 ist die System.Threading.ManualResetEventSlim -Klasse eine vereinfachte Alternative zu. ManualResetEventBeginning with the .NET Framework version 4.0, the System.Threading.ManualResetEventSlim class is a lightweight alternative to 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.Initializes a new instance of the ManualResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

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.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Dieses Feld ist konstant.This field is constant.

(Geerbt von WaitHandle)

Eigenschaften

Handle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.Gets or sets the native operating system handle.

(Geerbt von WaitHandle)
SafeWaitHandle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.Gets or sets the native operating system handle.

(Geerbt von WaitHandle)

Methoden

Close()

Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei.Releases all resources held by the current WaitHandle.

(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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Geerbt von MarshalByRefObject)
Dispose()

Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the WaitHandle class.

(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.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Geerbt von WaitHandle)
Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Geerbt von Object)
GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Geerbt von Object)
GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Geerbt von MarshalByRefObject)
Reset()

Legt den Zustand des Ereignisses auf „nicht signalisiert“ fest, sodass Threads blockiert werden.Sets the state of the event to nonsignaled, which causes threads to block.

Set()

Legt den Zustand des Ereignisses auf signalisiert fest und ermöglicht so einem oder mehreren wartenden Threads fortzufahren.Sets the state of the event to signaled, which allows one or more waiting threads to proceed.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Geerbt von Object)
WaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.Blocks the current thread until the current WaitHandle receives a signal.

(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Geerbt von WaitHandle)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Gibt alle vom WaitHandle verwendeten Ressourcen frei.Releases all resources used by the WaitHandle.

(Geerbt von WaitHandle)

Erweiterungsmethoden

GetSafeWaitHandle(WaitHandle)

Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.Sets a safe handle for a native operating system wait handle.

Gilt für:

Threadsicherheit

Diese Klasse ist Thread sicher.This class is thread safe.

Siehe auch