ManualResetEvent Klasa

Definicja

Przestrzeń nazw:

System.Threading

Zestaw:

System.Threading.dll

Źródło:

ManualResetEvent.cs

Reprezentuje zdarzenie synchronizacji wątków, które po zasygnalicie musi zostać zresetowane ręcznie. Tej klasy nie można dziedziczyć.

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

Dziedziczenie

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Przykłady

W poniższym przykładzie pokazano, jak działa ManualResetEvent. Przykład rozpoczyna się od ManualResetEvent w stanie niepodpisanym (czyli false jest przekazywany do konstruktora). W przykładzie są tworzone trzy wątki, z których każdy blokuje ManualResetEvent przez wywołanie metody WaitOne. Gdy użytkownik naciśnie Enter, przykład wywołuje metodę Set, która zwalnia wszystkie trzy wątki. Porównaj to z zachowaniem klasy AutoResetEvent, która zwalnia wątki pojedynczo, resetując automatycznie po każdej wersji.

Naciśnięcie Enter ponownie pokazuje, że ManualResetEvent pozostaje w stanie sygnału, dopóki nie zostanie wywołana jego metoda Reset: Przykład uruchamia dwa kolejne wątki. Te wątki nie blokują się podczas wywoływania metody WaitOne, ale zamiast tego są uruchamiane do ukończenia.

Naciśnięcie Enter ponownie powoduje wywołanie metody Reset i uruchomienie jeszcze jednego wątku, który blokuje wywołanie WaitOne. Naciśnięcie Enter po raz ostatni wywołuje Set, aby zwolnić ostatni wątek, a program kończy się.

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.

Uwagi

Używasz ManualResetEvent, AutoResetEventi EventWaitHandle do interakcji wątków (lub sygnalizowania wątków). Aby uzyskać więcej informacji, zobacz sekcję wątek lub sygnalizacyjną w artykule Omówienie elementów pierwotnych synchronizacji.

Gdy wątek rozpoczyna działanie, które musi zostać ukończone przed kontynuowaniem innych wątków, wywołuje ManualResetEvent.Reset, aby umieścić ManualResetEvent w stanie niesygnalizowany. Ten wątek można traktować jako kontrolowanie ManualResetEvent. Wątki wywołujące ManualResetEvent.WaitOne bloku, oczekujące na sygnał. Gdy wątek sterujący zakończy działanie, wywołuje ManualResetEvent.Set, aby zasygnalizować, że wątki oczekujące mogą kontynuować. Wszystkie oczekujące wątki są zwalniane.

Gdy zostanie zasygnalizowany, ManualResetEvent pozostanie zasygnalizowana do momentu ręcznego zresetowania przez wywołanie metody Reset(). Oznacza to, że wzywa do natychmiastowego zwrócenia WaitOne.

Stan początkowy ManualResetEvent można kontrolować, przekazując wartość logiczną do konstruktora: true, jeśli stan początkowy jest zasygnalizowany, a false w przeciwnym razie.

ManualResetEvent można również używać z metodami staticWaitAll i WaitAny.

Począwszy od programu .NET Framework w wersji 2.0, ManualResetEvent pochodzi z klasy EventWaitHandle. ManualResetEvent jest funkcjonalnie odpowiednikiem EventWaitHandle utworzonego za pomocą EventResetMode.ManualReset.

Nuta

W przeciwieństwie do klasy ManualResetEvent klasa EventWaitHandle zapewnia dostęp do nazwanych zdarzeń synchronizacji systemu.

Począwszy od programu .NET Framework w wersji 4.0, klasa System.Threading.ManualResetEventSlim jest uproszczoną alternatywą dla ManualResetEvent.

Konstruktory

ManualResetEvent(Boolean)

Inicjuje nowe wystąpienie klasy ManualResetEvent z wartością logiczną wskazującą, czy ustawić stan początkowy na sygnalizowany.

Pola

WaitTimeout

Wskazuje, że upłynął limit czasu operacji WaitAny(WaitHandle[], Int32, Boolean), zanim zostanie zasygnalizowana którakolwiek z dojść oczekiwania. To pole jest stałe. (Odziedziczone po WaitHandle)

Właściwości

Handle	Przestarzałe. Pobiera lub ustawia natywny uchwyt systemu operacyjnego. (Odziedziczone po WaitHandle)
SafeWaitHandle	Pobiera lub ustawia natywny uchwyt systemu operacyjnego. (Odziedziczone po WaitHandle)

Metody

Close()	Zwalnia wszystkie zasoby przechowywane przez bieżący WaitHandle. (Odziedziczone po WaitHandle)
CreateObjRef(Type)	Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject)
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy WaitHandle. (Odziedziczone po WaitHandle)
Dispose(Boolean)	Po zastąpieniu w klasie pochodnej zwalnia niezarządzane zasoby używane przez WaitHandlei opcjonalnie zwalnia zasoby zarządzane. (Odziedziczone po WaitHandle)
Equals(Object)	Określa, czy określony obiekt jest równy bieżącemu obiektowi. (Odziedziczone po Object)
GetAccessControl()	Pobiera obiekt EventWaitHandleSecurity reprezentujący zabezpieczenia kontroli dostępu dla nazwanego zdarzenia systemowego reprezentowanego przez bieżący obiekt EventWaitHandle. (Odziedziczone po EventWaitHandle)
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetLifetimeService()	Przestarzałe. Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
GetType()	Pobiera Type bieżącego wystąpienia. (Odziedziczone po Object)
InitializeLifetimeService()	Przestarzałe. Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Object. (Odziedziczone po Object)
MemberwiseClone(Boolean)	Tworzy płytkią kopię bieżącego obiektu MarshalByRefObject. (Odziedziczone po MarshalByRefObject)
Reset()	Ustawia stan zdarzenia na niepodpisany, powodując zablokowanie wątków. (Odziedziczone po EventWaitHandle)
Set()	Ustawia stan zdarzenia na zasygnalizowany, umożliwiając kontynuowanie co najmniej jednego wątku oczekiwania. (Odziedziczone po EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Ustawia zabezpieczenia kontroli dostępu dla nazwanego zdarzenia systemowego. (Odziedziczone po EventWaitHandle)
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
WaitOne()	Blokuje bieżący wątek, dopóki bieżący WaitHandle otrzyma sygnał. (Odziedziczone po WaitHandle)
WaitOne(Int32)	Blokuje bieżący wątek, dopóki bieżący WaitHandle odbiera sygnał, używając 32-bitowej liczby całkowitej ze znakiem, aby określić interwał czasu w milisekundach. (Odziedziczone po WaitHandle)
WaitOne(Int32, Boolean)	Blokuje bieżący wątek do momentu odebrania sygnału przez bieżącą WaitHandle przy użyciu 32-bitowej liczby całkowitej ze znakiem, aby określić interwał czasu i określić, czy należy zamknąć domenę synchronizacji przed oczekiwaniem. (Odziedziczone po WaitHandle)
WaitOne(TimeSpan)	Blokuje bieżący wątek do momentu odebrania sygnału przez bieżące wystąpienie przy użyciu TimeSpan w celu określenia interwału czasu. (Odziedziczone po WaitHandle)
WaitOne(TimeSpan, Boolean)	Blokuje bieżący wątek do momentu odebrania sygnału przez bieżące wystąpienie przy użyciu TimeSpan w celu określenia interwału czasu i określenia, czy należy zamknąć domenę synchronizacji przed oczekiwaniem. (Odziedziczone po WaitHandle)

Metody rozszerzania

GetAccessControl(EventWaitHandle)	Zwraca deskryptory zabezpieczeń dla określonego handle.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Ustawia deskryptory zabezpieczeń dla określonego uchwytu oczekiwania zdarzeń.
GetSafeWaitHandle(WaitHandle)	Pobiera bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Ustawia bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.

Bezpieczeństwo wątkowe

Ta klasa jest bezpieczna wątkiem.

Zobacz też

• WaitHandle
• zarządzanych wątków
• Omówienie elementów pierwotnych synchronizacji