ManualResetEvent Klasse

Definition

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

Object

WaitHandle

EventWaitHandle

ManualResetEvent

Vererbung

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Vererbung

Object

MarshalByRefObject

WaitHandle

ManualResetEvent

Attribute

ComVisibleAttribute

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, von denen jeder die -Methode durch Aufrufen der ManualResetEvent - WaitOne Methode blockiert. Wenn der Benutzer die EINGABETASTE drückt, ruft das Beispiel die Set -Methode auf, die alle drei Threads freigibt. Vergleichen Sie dies mit dem Verhalten der AutoResetEvent -Klasse, die Threads einzeln freigibt und nach jedem Release automatisch zurückgesetzt wird.

Durch erneutes Drücken der EINGABETASTE wird veranschaulicht, dass der ManualResetEvent im signalierten Zustand verbleibt, bis die Reset -Methode aufgerufen wird: Im Beispiel werden zwei weitere Threads gestartet. Diese Threads werden beim Aufrufen der WaitOne -Methode nicht blockiert, sondern bis zum Abschluss ausgeführt.

Durch erneutes Drücken der EINGABETASTE wird im Beispiel die Reset -Methode aufgerufen und ein weiterer Thread gestartet, der blockiert, wenn aufgerufen wird WaitOne. Durch drücken der EINGABETASTE wird ein letztes Mal aufgerufen Set , um den letzten Thread freizugeben, 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, AutoResetEventund EventWaitHandle für die 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 signalisierenden Zustand zu versetzen ManualResetEvent . Dieser Thread kann als Steuerung von ManualResetEventangesehen werden. Threads, die Den ManualResetEvent.WaitOne-Block aufrufen, warten auf das Signal. Wenn der steuernde Thread die Aktivität abgeschlossen hat, ruft er ManualResetEvent.Set auf, um zu signalisieren, dass die wartenden Threads fortfahren können. Alle wartenden Threads werden freigegeben.

Sobald das Signal signalisiert wurde, wird so lange signalisiert, ManualResetEvent bis es durch Aufrufen der Reset() -Methode manuell zurückgesetzt wird. Das heißt, aufruft WaitOne sofort zurück.

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

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

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

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

Konstruktoren

Felder

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Erweiterungsmethoden

Gilt für:

Threadsicherheit

Diese Klasse ist threadsicher.

Weitere Informationen

• WaitHandle
• Verwaltetes Threading
• Übersicht über Synchronisierungsprimitiven