AutoResetEvent Clase

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Threading.dll

Source:

AutoResetEvent.cs

Representa un evento de sincronización de subprocesos que, cuando se señala, libera un único subproceso en espera y, a continuación, se restablece automáticamente. Esta clase no se puede heredar.

public ref class AutoResetEvent sealed : System::Threading::EventWaitHandle

public sealed class AutoResetEvent : System.Threading.EventWaitHandle

type AutoResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class AutoResetEvent
Inherits EventWaitHandle

Herencia

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

AutoResetEvent

Ejemplos

En el ejemplo siguiente se muestra cómo usar AutoResetEvent para liberar un subproceso a la vez, llamando al método Set (en la clase base) cada vez que el usuario presiona la tecla Entrar. En el ejemplo se inician tres subprocesos, que esperan en una AutoResetEvent que se creó en el estado señalado. El primer subproceso se libera inmediatamente, porque el AutoResetEvent ya está en estado señalado. Esto restablece el AutoResetEvent al estado no señalado, de modo que los subprocesos posteriores bloqueen. Los subprocesos bloqueados no se liberan hasta que el usuario los libera de uno en uno presionando el tecla Entrar.

Después de liberar los subprocesos del primer AutoResetEvent, esperan en otra AutoResetEvent que se creó en el estado no señalado. Los tres subprocesos bloquean, por lo que el método Set debe llamarse tres veces para liberarlos todos.

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    static AutoResetEvent^ event_1 = gcnew AutoResetEvent(true);
    static AutoResetEvent^ event_2 = gcnew AutoResetEvent(false);

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1->WaitOne();
        Console::WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console::WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2->WaitOne();
        Console::WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console::WriteLine("{0} ends.", name);
    }

public:
    static void Demo()
    {
        Console::WriteLine("Press Enter to create three threads and start them.\r\n" +
                           "The threads wait on AutoResetEvent #1, which was created\r\n" +
                           "in the signaled state, so the first thread is released.\r\n" +
                           "This puts AutoResetEvent #1 into the unsignaled state.");
        Console::ReadLine();
            
        for (int i = 1; i < 4; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(&ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }
        Thread::Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console::WriteLine("Press Enter to release another thread.");
            Console::ReadLine();
            event_1->Set();
            Thread::Sleep(250);
        }

        Console::WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console::WriteLine("Press Enter to release a thread.");
            Console::ReadLine();
            event_2->Set();
            Thread::Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console::Readline();
    }
};

void main()
{
    Example::Demo();
}

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */

using System;
using System.Threading;

// Visual Studio: Replace the default class in a Console project with 
//                the following class.
class Example
{
    private static AutoResetEvent event_1 = new AutoResetEvent(true);
    private static AutoResetEvent event_2 = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Press Enter to create three threads and start them.\r\n" +
                          "The threads wait on AutoResetEvent #1, which was created\r\n" +
                          "in the signaled state, so the first thread is released.\r\n" +
                          "This puts AutoResetEvent #1 into the unsignaled state.");
        Console.ReadLine();
            
        for (int i = 1; i < 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }
        Thread.Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine("Press Enter to release another thread.");
            Console.ReadLine();
            event_1.Set();
            Thread.Sleep(250);
        }

        Console.WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Press Enter to release a thread.");
            Console.ReadLine();
            event_2.Set();
            Thread.Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console.Readline();
    }

    static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console.WriteLine("{0} ends.", name);
    }
}

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */

Imports System.Threading

' Visual Studio: Replace the default class in a Console project with 
'                the following class.
Class Example

    Private Shared event_1 As New AutoResetEvent(True)
    Private Shared event_2 As New AutoResetEvent(False)

    <MTAThread()> _
    Shared Sub Main()
    
        Console.WriteLine("Press Enter to create three threads and start them." & vbCrLf & _
                          "The threads wait on AutoResetEvent #1, which was created" & vbCrLf & _
                          "in the signaled state, so the first thread is released." & vbCrLf & _
                          "This puts AutoResetEvent #1 into the unsignaled state.")
        Console.ReadLine()
            
        For i As Integer = 1 To 3
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next
        Thread.Sleep(250)

        For i As Integer = 1 To 2
            Console.WriteLine("Press Enter to release another thread.")
            Console.ReadLine()

            event_1.Set()
            Thread.Sleep(250)
        Next

        Console.WriteLine(vbCrLf & "All threads are now waiting on AutoResetEvent #2.")
        For i As Integer = 1 To 3
            Console.WriteLine("Press Enter to release a thread.")
            Console.ReadLine()

            event_2.Set()
            Thread.Sleep(250)
        Next

        ' Visual Studio: Uncomment the following line.
        'Console.Readline()
    End Sub

    Shared Sub ThreadProc()
    
        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name)
        event_1.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name)

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name)
        event_2.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name)

        Console.WriteLine("{0} ends.", name)
    End Sub
End Class

' This example produces output similar to the following:
'
'Press Enter to create three threads and start them.
'The threads wait on AutoResetEvent #1, which was created
'in the signaled state, so the first thread is released.
'This puts AutoResetEvent #1 into the unsignaled state.
'
'Thread_1 waits on AutoResetEvent #1.
'Thread_1 is released from AutoResetEvent #1.
'Thread_1 waits on AutoResetEvent #2.
'Thread_3 waits on AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #1.
'Press Enter to release another thread.
'
'Thread_3 is released from AutoResetEvent #1.
'Thread_3 waits on AutoResetEvent #2.
'Press Enter to release another thread.
'
'Thread_2 is released from AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #2.
'
'All threads are now waiting on AutoResetEvent #2.
'Press Enter to release a thread.
'
'Thread_2 is released from AutoResetEvent #2.
'Thread_2 ends.
'Press Enter to release a thread.
'
'Thread_1 is released from AutoResetEvent #2.
'Thread_1 ends.
'Press Enter to release a thread.
'
'Thread_3 is released from AutoResetEvent #2.
'Thread_3 ends.

Comentarios

Use AutoResetEvent, ManualResetEventy EventWaitHandle para la interacción de subprocesos (o señalización de subprocesos). Para obtener más información, consulte interacción de subprocesos.

Un subproceso espera una señal llamando a AutoResetEvent.WaitOne. Si el AutoResetEvent está en estado no señalado, el subproceso se bloquea hasta que se llama a autoResetEvent.Set. Llamar a Set indica AutoResetEvent liberar un subproceso en espera. AutoResetEvent permanece señalado hasta que se llama a Reset o se libera un único subproceso en espera, en cuyo momento vuelve automáticamente al estado no señalado.

Si no hay subprocesos en espera cuando el AutoResetEvent entra en un estado señalado, el estado permanece señalado hasta que un subproceso observa la señal (llamando a WaitOne). Ese subproceso no bloquea: el AutoResetEvent libera el subproceso inmediatamente y vuelve al estado no señalizado.

Importante

No hay ninguna garantía de que todas las llamadas al método Set liberarán un subproceso. Si dos llamadas están demasiado cerca, de modo que la segunda se produzca antes de que se libere un subproceso, solo se libera un subproceso. Es como si la segunda llamada no sucediera. Además, si se llama a Set cuando no hay subprocesos en espera y el AutoResetEvent ya está señalado, la llamada no tiene ningún efecto.

Puede controlar el estado inicial de un AutoResetEvent pasando un valor booleano al constructor: true si se señala el estado inicial y false de lo contrario.

AutoResetEvent también se puede usar con los métodos staticWaitAll y WaitAny.

AutoResetEvent deriva de la clase EventWaitHandle. Un AutoResetEvent es funcionalmente equivalente a un EventWaitHandle creado con EventResetMode.AutoReset.

Nota

A diferencia de la clase AutoResetEvent, la clase EventWaitHandle proporciona acceso a eventos de sincronización del sistema con nombre.

Importante

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de usar el tipo, debe eliminarlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch. Para eliminarlo indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea la sección "Using an Object that Implements IDisposable" (Usar un objeto que implementa IDisposable) en la página de interfaz de IDisposable.

Constructores

AutoResetEvent(Boolean)

Inicializa una nueva instancia de la clase AutoResetEvent con un valor booleano que indica si se va a establecer el estado inicial en señalizado.

Campos

WaitTimeout

Indica que se ha agotado el tiempo de espera de una operación WaitAny(WaitHandle[], Int32, Boolean) antes de que se señalizara cualquiera de los identificadores de espera. Este campo es constante. (Heredado de WaitHandle)

Propiedades

Handle	Obsoletos. Obtiene o establece el identificador del sistema operativo nativo. (Heredado de WaitHandle)
SafeWaitHandle	Obtiene o establece el identificador del sistema operativo nativo. (Heredado de WaitHandle)

Métodos

Close()	Libera todos los recursos mantenidos por el WaitHandleactual. (Heredado de WaitHandle)
CreateObjRef(Type)	Crea un objeto que contiene toda la información pertinente necesaria para generar un proxy usado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos usados por la instancia actual de la clase WaitHandle. (Heredado de WaitHandle)
Dispose(Boolean)	Cuando se reemplaza en una clase derivada, libera los recursos no administrados usados por el WaitHandley, opcionalmente, libera los recursos administrados. (Heredado de WaitHandle)
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
GetAccessControl()	Obtiene un objeto EventWaitHandleSecurity que representa la seguridad del control de acceso para el evento del sistema con nombre representado por el objeto EventWaitHandle actual. (Heredado de EventWaitHandle)
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
Reset()	Establece el estado del evento en no asignado, lo que provoca que los subprocesos se bloqueen. (Heredado de EventWaitHandle)
Set()	Establece el estado del evento en señalizado, lo que permite que uno o varios subprocesos en espera continúen. (Heredado de EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Establece la seguridad del control de acceso para un evento del sistema con nombre. (Heredado de EventWaitHandle)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
WaitOne()	Bloquea el subproceso actual hasta que el WaitHandle actual recibe una señal. (Heredado de WaitHandle)
WaitOne(Int32)	Bloquea el subproceso actual hasta que el WaitHandle actual recibe una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo en milisegundos. (Heredado de WaitHandle)
WaitOne(Int32, Boolean)	Bloquea el subproceso actual hasta que el WaitHandle actual recibe una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo y especificar si se sale del dominio de sincronización antes de la espera. (Heredado de WaitHandle)
WaitOne(TimeSpan)	Bloquea el subproceso actual hasta que la instancia actual recibe una señal mediante un TimeSpan para especificar el intervalo de tiempo. (Heredado de WaitHandle)
WaitOne(TimeSpan, Boolean)	Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando un TimeSpan para especificar el intervalo de tiempo y especificando si se sale del dominio de sincronización antes de la espera. (Heredado de WaitHandle)

Métodos de extensión

GetAccessControl(EventWaitHandle)	Devuelve los descriptores de seguridad del handleespecificado.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Establece los descriptores de seguridad para el identificador de espera de eventos especificado.
GetSafeWaitHandle(WaitHandle)	Obtiene el identificador seguro de un identificador de espera de sistema operativo nativo.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Establece un identificador seguro para un identificador de espera de sistema operativo nativo.

Seguridad para subprocesos

Esta clase es segura para subprocesos.

Consulte también

• WaitHandle
• de subprocesos administrados
• Información general sobre las primitivas de sincronización