ManualResetEvent Classe

Definição

Representa um evento de sincronização de thread que, quando sinalizado, deve ser redefinido manualmente.Represents a thread synchronization event that, when signaled, must be reset manually. Essa classe não pode ser herdada.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
Herança
ManualResetEvent
Herança
Herança
Atributos

Exemplos

O exemplo a seguir demonstra como o ManualResetEvent funciona.The following example demonstrates how ManualResetEvent works. O exemplo começa com um ManualResetEvent no estado não sinalizado (ou seja, false é passado para o Construtor).The example starts with a ManualResetEvent in the unsignaled state (that is, false is passed to the constructor). O exemplo cria três threads, cada um dos quais blocos no ManualResetEvent chamando seu WaitOne método.The example creates three threads, each of which blocks on the ManualResetEvent by calling its WaitOne method. Quando o usuário pressiona a tecla Enter , o exemplo chama o Set método, que libera todos os três threads.When the user presses the Enter key, the example calls the Set method, which releases all three threads. Compare isso com o comportamento da AutoResetEvent classe, que libera threads um de cada vez, redefinindo automaticamente após cada versão.Contrast this with the behavior of the AutoResetEvent class, which releases threads one at a time, resetting automatically after each release.

Pressionar a tecla Enter novamente demonstra que o ManualResetEvent permanece no estado sinalizado até que seu Reset método seja chamado: o exemplo inicia mais dois threads.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. Esses threads não bloqueiam quando chamam o WaitOne método, mas, em vez disso, executam até a conclusão.These threads do not block when they call the WaitOne method, but instead run to completion.

Pressionar a tecla Enter novamente faz com que o exemplo chame o Reset método e inicie mais um thread, que é bloqueado quando ele chama 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. Pressionar a tecla Enter uma última vez chama Set para liberar o último thread e o programa termina.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.

Comentários

Você usa ManualResetEvent , AutoResetEvent e EventWaitHandle para a interação de thread (ou sinalização de thread).You use ManualResetEvent, AutoResetEvent, and EventWaitHandle for thread interaction (or thread signaling). Para obter mais informações, consulte a seção interação do thread ou sinalização do artigo visão geral do primitivos de sincronização .For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

Quando um thread inicia uma atividade que deve ser concluída antes que outros threads continuem, ele chama ManualResetEvent. Reset para colocar ManualResetEvent no estado não sinalizado.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. Esse thread pode ser considerado como controle do ManualResetEvent .This thread can be thought of as controlling the ManualResetEvent. Threads que chamam o bloco ManualResetEvent. WaitOne , aguardando o sinal.Threads that call ManualResetEvent.WaitOne block, awaiting the signal. Quando o thread de controle conclui a atividade, ele chama ManualResetEvent. Set para sinalizar que os threads em espera podem continuar.When the controlling thread completes the activity, it calls ManualResetEvent.Set to signal that the waiting threads can proceed. Todos os threads em espera são liberados.All waiting threads are released.

Depois de sinalizado, ManualResetEvent permanece sinalizado até que seja redefinido manualmente chamando o Reset() método.Once it has been signaled, ManualResetEvent remains signaled until it is manually reset by calling the Reset() method. Ou seja, as chamadas para WaitOne retornar imediatamente.That is, calls to WaitOne return immediately.

Você pode controlar o estado inicial de um ManualResetEvent passando um valor booliano para o construtor: true se o estado inicial for sinalizado e, false caso contrário,.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 também pode ser usado com os static WaitAll WaitAny métodos e.ManualResetEvent can also be used with the static WaitAll and WaitAny methods.

A partir da versão .NET Framework 2,0, ManualResetEvent deriva da EventWaitHandle classe.Beginning with the .NET Framework version 2.0, ManualResetEvent derives from the EventWaitHandle class. Um ManualResetEvent é funcionalmente equivalente a um EventWaitHandle criado com EventResetMode.ManualReset .A ManualResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.ManualReset.

Observação

Ao contrário da ManualResetEvent classe, a EventWaitHandle classe fornece acesso aos eventos de sincronização do sistema nomeados.Unlike the ManualResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

A partir da versão .NET Framework 4,0, a System.Threading.ManualResetEventSlim classe é uma alternativa leve ao ManualResetEvent .Beginning with the .NET Framework version 4.0, the System.Threading.ManualResetEventSlim class is a lightweight alternative to ManualResetEvent.

Construtores

ManualResetEvent(Boolean)

Inicializa uma nova instância da classe ManualResetEvent com um valor booliano que indica se é necessário definir o estado inicial como sinalizado.Initializes a new instance of the ManualResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

Campos

WaitTimeout

Indica que uma operação WaitAny(WaitHandle[], Int32, Boolean) atingiu o tempo limite antes que algum dos identificadores de espera fosse sinalizado.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Este campo é constante.This field is constant.

(Herdado de WaitHandle)

Propriedades

Handle
Obsoleto.

Obtém ou define o identificador de sistema operacional nativo.Gets or sets the native operating system handle.

(Herdado de WaitHandle)
SafeWaitHandle

Obtém ou define o identificador de sistema operacional nativo.Gets or sets the native operating system handle.

(Herdado de WaitHandle)

Métodos

Close()

Libera todos os recursos mantidos pelo WaitHandle atual.Releases all resources held by the current WaitHandle.

(Herdado de WaitHandle)
CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Herdado de MarshalByRefObject)
Dispose()

Libera todos os recursos usados pela instância atual da classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Herdado de WaitHandle)
Dispose(Boolean)

Quando substituído em uma classe derivada, libera os recursos não gerenciados usados pelo WaitHandle e, opcionalmente, libera os recursos gerenciados.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Herdado de WaitHandle)
Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetAccessControl()

Obtém um objeto EventWaitHandleSecurity que representa a segurança de controle de acesso para o evento do sistema nomeado representado pelo objeto EventWaitHandle atual.Gets an EventWaitHandleSecurity object that represents the access control security for the named system event represented by the current EventWaitHandle object.

(Herdado de EventWaitHandle)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetLifetimeService()

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
InitializeLifetimeService()

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

(Herdado de MarshalByRefObject)
Reset()

Define o estado do evento como não sinalizado, o que causa o bloqueio dos threads.Sets the state of the event to nonsignaled, which causes threads to block.

Reset()

Define o estado do evento como não sinalizado, fazendo com que os threads sejam bloqueados.Sets the state of the event to nonsignaled, causing threads to block.

(Herdado de EventWaitHandle)
Set()

Define o estado do evento a ser sinalizado, permitindo que um ou mais threads de espera prossigam.Sets the state of the event to signaled, which allows one or more waiting threads to proceed.

Set()

Define o estado do evento a ser sinalizado, permitindo que um ou mais threads de espera prossigam.Sets the state of the event to signaled, allowing one or more waiting threads to proceed.

(Herdado de EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)

Define a segurança de controle de acesso para um evento do sistema nomeado.Sets the access control security for a named system event.

(Herdado de EventWaitHandle)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)
WaitOne()

Bloqueia o thread atual até que o WaitHandle atual receba um sinal.Blocks the current thread until the current WaitHandle receives a signal.

(Herdado de WaitHandle)
WaitOne(Int32)

Bloqueia o thread atual até que o WaitHandle atual receba um sinal, usando um inteiro com sinal de 32 bits para especificar o intervalo de tempo em milissegundos.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Herdado de WaitHandle)
WaitOne(Int32, Boolean)

Bloqueia o thread atual até que o WaitHandle atual receba um sinal, usando um inteiro com sinal de 32 bits para especificar o intervalo de tempo e especificar se sairá do domínio de sincronização antes da espera.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.

(Herdado de WaitHandle)
WaitOne(TimeSpan)

Bloqueia o thread atual até que a instância atual receba um sinal, usando um TimeSpan para especificar o intervalo de tempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Herdado de WaitHandle)
WaitOne(TimeSpan, Boolean)

Bloqueia o thread atual até que a instância atual receba um sinal, usando um TimeSpan para especificar o intervalo de tempo e especificar se sairá do domínio de sincronização antes da espera.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.

(Herdado de WaitHandle)

Implantações explícitas de interface

IDisposable.Dispose()

Esta API dá suporte à infraestrutura do produto e não deve ser usada diretamente do seu código.

Libera todos os recursos usados pelo WaitHandle.Releases all resources used by the WaitHandle.

(Herdado de WaitHandle)

Métodos de Extensão

GetAccessControl(EventWaitHandle)

Retorna os descritores de segurança para o handle especificado.Returns the security descriptors for the specified handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Define os descritores de segurança para o identificador de espera de evento especificado.Sets the security descriptors for the specified event wait handle.

GetSafeWaitHandle(WaitHandle)

Obtém o identificador seguro para um identificador de espera nativo do sistema operacional.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Define um identificador seguro para um identificador de espera do sistema operacional nativo.Sets a safe handle for a native operating system wait handle.

Aplica-se a

Acesso thread-safe

Essa classe é thread-safe.This class is thread safe.

Veja também