ManualResetEvent Klasa

Definicja

Reprezentuje zdarzenie synchronizacji wątku, które po zasygnalizowaniu należy zresetować ręcznie.Represents a thread synchronization event that, when signaled, must be reset manually. Klasa ta nie może być dziedziczona.This class cannot be inherited.

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
Dziedziczenie
ManualResetEvent
Dziedziczenie
Dziedziczenie
Atrybuty

Przykłady

Poniższy przykład ilustruje sposób ManualResetEvent działania programu.The following example demonstrates how ManualResetEvent works. Przykład rozpoczyna się od znaku ManualResetEvent w stanie niesygnalizującym (czyli false jest przesyłany do konstruktora).The example starts with a ManualResetEvent in the unsignaled state (that is, false is passed to the constructor). Przykład tworzy trzy wątki, z których każdy jest blokowany ManualResetEvent przez wywołanie WaitOne metody.The example creates three threads, each of which blocks on the ManualResetEvent by calling its WaitOne method. Gdy użytkownik naciśnie klawisz Enter , przykład wywołuje Set metodę, która zwalnia wszystkie trzy wątki.When the user presses the Enter key, the example calls the Set method, which releases all three threads. Jest to kontrast z zachowaniem AutoResetEvent klasy, która zwalnia wątki pojedynczo, resetuje się automatycznie po każdej wersji.Contrast this with the behavior of the AutoResetEvent class, which releases threads one at a time, resetting automatically after each release.

Ponowne naciśnięcie klawisza Enter pokazuje, że ManualResetEvent pozostało w stanie sygnalizowania do momentu Reset wywołania jego metody: przykład uruchamia dwa kolejne wątki.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. Te wątki nie blokują, gdy wywołujący WaitOne metodę, ale zamiast tego uruchamiają się do ukończenia.These threads do not block when they call the WaitOne method, but instead run to completion.

Naciśnięcie klawisza Enter spowoduje ponowne wywołanie Reset metody i uruchomienie jednego wątku, który blokuje czas wywoływania WaitOne .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. Naciśnięcie klawisza Enter po raz ostatni wywołuje wywołania Set ostatniego wątku, a program zostaje zakończony.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.

Uwagi

Używasz ManualResetEvent , AutoResetEvent i EventWaitHandle do interakcji wątku (lub sygnalizacji wątku).You use ManualResetEvent, AutoResetEvent, and EventWaitHandle for thread interaction (or thread signaling). Aby uzyskać więcej informacji, zobacz interakcja wątku lub sekcja sygnalizowanie w artykule Omówienie elementów pierwotnych synchronizacji .For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

Gdy wątek rozpocznie działanie, które musi zostać zakończone przed kontynuowaniem innych wątków, wywoła ManualResetEvent. Reset , aby umieścić ManualResetEvent w stanie niesygnalizującym.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. Ten wątek może być uważany za kontrolujący ManualResetEvent .This thread can be thought of as controlling the ManualResetEvent. Wątki, które wywołują blok ManualResetEvent. WaitOne , czekające na sygnał.Threads that call ManualResetEvent.WaitOne block, awaiting the signal. Gdy wątek kontrolny kończy działanie, wywołuje ManualResetEvent. Set , aby sygnalizować, że oczekujące wątki mogą działać.When the controlling thread completes the activity, it calls ManualResetEvent.Set to signal that the waiting threads can proceed. Wszystkie oczekujące wątki są wydane.All waiting threads are released.

Po zasygnalizowaniu ManualResetEvent zostanie on zasygnalizowani do momentu zresetowania go ręcznie przez wywołanie Reset() metody.Once it has been signaled, ManualResetEvent remains signaled until it is manually reset by calling the Reset() method. Oznacza to, że wywołania są WaitOne zwracane natychmiast.That is, calls to WaitOne return immediately.

Możesz sterować początkowym stanem a ManualResetEvent przez przekazanie wartości logicznej do konstruktora: true Jeśli początkowy stan jest sygnalizowane i false w inny sposób.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.

ManualResetEvent można go również używać z static WaitAll WaitAny metodami i.ManualResetEvent can also be used with the static WaitAll and WaitAny methods.

Począwszy od .NET Framework w wersji 2,0, ManualResetEvent pochodzi od EventWaitHandle klasy.Beginning with the .NET Framework version 2.0, ManualResetEvent derives from the EventWaitHandle class. A ManualResetEvent jest funkcjonalnie równoważne z EventWaitHandle utworzonym za pomocą EventResetMode.ManualReset .A ManualResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.ManualReset.

Uwaga

W przeciwieństwie do ManualResetEvent klasy, EventWaitHandle Klasa zapewnia dostęp do nazwanych zdarzeń synchronizacji systemu.Unlike the ManualResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

Począwszy od .NET Framework w wersji 4,0, System.Threading.ManualResetEventSlim Klasa jest lekkim alternatywą dla ManualResetEvent .Beginning with the .NET Framework version 4.0, the System.Threading.ManualResetEventSlim class is a lightweight alternative to ManualResetEvent.

Konstruktory

ManualResetEvent(Boolean)

Inicjuje nowe wystąpienie ManualResetEvent klasy za pomocą wartości logicznej wskazującej, czy ustawić początkowy stan do sygnalizowania.Initializes a new instance of the ManualResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

Pola

WaitTimeout

Wskazuje, że WaitAny(WaitHandle[], Int32, Boolean) upłynął limit czasu operacji przed zasygnalizowaniem dowolnego z dojść oczekiwania.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. To pole jest stałe.This field is constant.

(Odziedziczone po WaitHandle)

Właściwości

Handle
Nieaktualne.

Pobiera lub ustawia natywne dojście systemu operacyjnego.Gets or sets the native operating system handle.

(Odziedziczone po WaitHandle)
SafeWaitHandle

Pobiera lub ustawia natywne dojście systemu operacyjnego.Gets or sets the native operating system handle.

(Odziedziczone po WaitHandle)

Metody

Close()

Zwalnia wszystkie zasoby przechowywane przez bieżące WaitHandle .Releases all resources held by the current WaitHandle.

(Odziedziczone po WaitHandle)
CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Odziedziczone po WaitHandle)
Dispose(Boolean)

Gdy jest zastępowany w klasie pochodnej, zwalnia niezarządzane zasoby używane przez WaitHandle program i opcjonalnie zwalnia zarządzane zasoby.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Odziedziczone po WaitHandle)
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetAccessControl()

Pobiera EventWaitHandleSecurity obiekt reprezentujący zabezpieczenia kontroli dostępu dla nazwanego zdarzenia systemowego reprezentowanego przez bieżący EventWaitHandle obiekt.Gets an EventWaitHandleSecurity object that represents the access control security for the named system event represented by the current EventWaitHandle object.

(Odziedziczone po EventWaitHandle)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
Reset()

Ustawia stan zdarzenia na Niesygnalizowane, co powoduje zablokowanie wątków.Sets the state of the event to nonsignaled, which causes threads to block.

Reset()

Ustawia stan zdarzenia na Niesygnalizowane, powodując zablokowanie wątków.Sets the state of the event to nonsignaled, causing threads to block.

(Odziedziczone po EventWaitHandle)
Set()

Ustawia stan zdarzenia, które ma być sygnalizowane przez co najmniej jeden oczekujący wątek.Sets the state of the event to signaled, which allows one or more waiting threads to proceed.

Set()

Ustawia stan zdarzenia, które ma być sygnalizowane przez co najmniej jeden oczekujący wątek.Sets the state of the event to signaled, allowing one or more waiting threads to proceed.

(Odziedziczone po EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)

Ustawia zabezpieczenia kontroli dostępu dla nazwanego zdarzenia systemowego.Sets the access control security for a named system event.

(Odziedziczone po EventWaitHandle)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
WaitOne()

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału.Blocks the current thread until the current WaitHandle receives a signal.

(Odziedziczone po WaitHandle)
WaitOne(Int32)

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej podpisanej liczby całkowitej w celu określenia interwału czasu w milisekundach.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Odziedziczone po WaitHandle)
WaitOne(Int32, Boolean)

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej podpisanej liczby całkowitej w celu określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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.

(Odziedziczone po WaitHandle)
WaitOne(TimeSpan)

Blokuje bieżący wątek do momentu otrzymania przez bieżące wystąpienie sygnału przy użyciu TimeSpan do określenia interwału czasu.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Odziedziczone po WaitHandle)
WaitOne(TimeSpan, Boolean)

Blokuje bieżący wątek do momentu odebrania przez bieżące wystąpienie sygnału przy użyciu TimeSpan do określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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.

(Odziedziczone po WaitHandle)

Jawne implementacje interfejsu

IDisposable.Dispose()

Ten interfejs API obsługuje infrastrukturę produktu i nie jest przeznaczony do użycia bezpośrednio z poziomu kodu.

Zwalnia wszelkie zasoby używane przez element WaitHandle.Releases all resources used by the WaitHandle.

(Odziedziczone po WaitHandle)

Metody rozszerzania

GetAccessControl(EventWaitHandle)

Zwraca deskryptory zabezpieczeń dla określonego elementu handle .Returns the security descriptors for the specified handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Ustawia deskryptory zabezpieczeń dla określonego uchwytu oczekiwania na zdarzenie.Sets the security descriptors for the specified event wait handle.

GetSafeWaitHandle(WaitHandle)

Pobiera Bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Ustawia Bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.Sets a safe handle for a native operating system wait handle.

Dotyczy

Bezpieczeństwo wątkowe

Ta klasa jest bezpieczna wątkowo.This class is thread safe.

Zobacz też