WaitHandle Clase

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Runtime.dll

Source:

WaitHandle.cs

Encapsula los objetos específicos del sistema operativo que esperan obtener un acceso exclusivo a los recursos compartidos.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable

public abstract class WaitHandle : MarshalByRefObject, IDisposable

type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable

Herencia

Object

MarshalByRefObject

WaitHandle

Derivado

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

Implementaciones

IDisposable

Ejemplos

En el ejemplo de código siguiente se muestra cómo dos subprocesos pueden realizar tareas en segundo plano mientras el subproceso main espera a que las tareas se completen mediante los métodos estáticos WaitAny y WaitAll de la WaitHandle clase .

using namespace System;
using namespace System::Threading;

public ref class WaitHandleExample
{
    // Define a random number generator for testing.
private:
    static Random^ random = gcnew Random();
public:
    static void DoTask(Object^ state)
    {
        AutoResetEvent^ autoReset = (AutoResetEvent^) state;
        int time = 1000 * random->Next(2, 10);
        Console::WriteLine("Performing a task for {0} milliseconds.", time);
        Thread::Sleep(time);
        autoReset->Set();
    }
};

int main()
{
    // Define an array with two AutoResetEvent WaitHandles.
    array<WaitHandle^>^ handles = gcnew array<WaitHandle^> {
        gcnew AutoResetEvent(false), gcnew AutoResetEvent(false)};

    // Queue up two tasks on two different threads;
    // wait until all tasks are completed.
    DateTime timeInstance = DateTime::Now;
    Console::WriteLine("Main thread is waiting for BOTH tasks to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    WaitHandle::WaitAll(handles);
    // The time shown below should match the longest task.
    Console::WriteLine("Both tasks are completed (time waited={0})",
        (DateTime::Now - timeInstance).TotalMilliseconds);

    // Queue up two tasks on two different threads;
    // wait until any tasks are completed.
    timeInstance = DateTime::Now;
    Console::WriteLine();
    Console::WriteLine("The main thread is waiting for either task to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    int index = WaitHandle::WaitAny(handles);
    // The time shown below should match the shortest task.
    Console::WriteLine("Task {0} finished first (time waited={1}).",
        index + 1, (DateTime::Now - timeInstance).TotalMilliseconds);
}

// This code produces the following sample output.
//
// Main thread is waiting for BOTH tasks to complete.
// Performing a task for 7000 milliseconds.
// Performing a task for 4000 milliseconds.
// Both tasks are completed (time waited=7064.8052)

// The main thread is waiting for either task to complete.
// Performing a task for 2000 milliseconds.
// Performing a task for 2000 milliseconds.
// Task 1 finished first (time waited=2000.6528).

using System;
using System.Threading;

public sealed class App
{
    // Define an array with two AutoResetEvent WaitHandles.
    static WaitHandle[] waitHandles = new WaitHandle[]
    {
        new AutoResetEvent(false),
        new AutoResetEvent(false)
    };

    // Define a random number generator for testing.
    static Random r = new Random();

    static void Main()
    {
        // Queue up two tasks on two different threads;
        // wait until all tasks are completed.
        DateTime dt = DateTime.Now;
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        WaitHandle.WaitAll(waitHandles);
        // The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})",
            (DateTime.Now - dt).TotalMilliseconds);

        // Queue up two tasks on two different threads;
        // wait until any task is completed.
        dt = DateTime.Now;
        Console.WriteLine();
        Console.WriteLine("The main thread is waiting for either task to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        int index = WaitHandle.WaitAny(waitHandles);
        // The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).",
            index + 1, (DateTime.Now - dt).TotalMilliseconds);
    }

    static void DoTask(Object state)
    {
        AutoResetEvent are = (AutoResetEvent) state;
        int time = 1000 * r.Next(2, 10);
        Console.WriteLine("Performing a task for {0} milliseconds.", time);
        Thread.Sleep(time);
        are.Set();
    }
}

// This code produces output similar to the following:
//
//  Main thread is waiting for BOTH tasks to complete.
//  Performing a task for 7000 milliseconds.
//  Performing a task for 4000 milliseconds.
//  Both tasks are completed (time waited=7064.8052)
//
//  The main thread is waiting for either task to complete.
//  Performing a task for 2000 milliseconds.
//  Performing a task for 2000 milliseconds.
//  Task 1 finished first (time waited=2000.6528).

Imports System.Threading

NotInheritable Public Class App
    ' Define an array with two AutoResetEvent WaitHandles.
    Private Shared waitHandles() As WaitHandle = _
        {New AutoResetEvent(False), New AutoResetEvent(False)}
    
    ' Define a random number generator for testing.
    Private Shared r As New Random()
    
    <MTAThreadAttribute> _
    Public Shared Sub Main() 
        ' Queue two tasks on two different threads; 
        ' wait until all tasks are completed.
        Dim dt As DateTime = DateTime.Now
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        WaitHandle.WaitAll(waitHandles)
        ' The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})", _
            (DateTime.Now - dt).TotalMilliseconds)
        
        ' Queue up two tasks on two different threads; 
        ' wait until any tasks are completed.
        dt = DateTime.Now
        Console.WriteLine()
        Console.WriteLine("The main thread is waiting for either task to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        Dim index As Integer = WaitHandle.WaitAny(waitHandles)
        ' The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).", _
            index + 1,(DateTime.Now - dt).TotalMilliseconds)
    
    End Sub
    
    Shared Sub DoTask(ByVal state As [Object]) 
        Dim are As AutoResetEvent = CType(state, AutoResetEvent)
        Dim time As Integer = 1000 * r.Next(2, 10)
        Console.WriteLine("Performing a task for {0} milliseconds.", time)
        Thread.Sleep(time)
        are.Set()
    
    End Sub
End Class

' This code produces output similar to the following:
'
'  Main thread is waiting for BOTH tasks to complete.
'  Performing a task for 7000 milliseconds.
'  Performing a task for 4000 milliseconds.
'  Both tasks are completed (time waited=7064.8052)
' 
'  The main thread is waiting for either task to complete.
'  Performing a task for 2000 milliseconds.
'  Performing a task for 2000 milliseconds.
'  Task 1 finished first (time waited=2000.6528).

Comentarios

La WaitHandle clase encapsula un identificador de sincronización de sistema operativo nativo y se usa para representar todos los objetos de sincronización en tiempo de ejecución que permiten varias operaciones de espera. Para obtener una comparación de los identificadores de espera con otros objetos de sincronización, vea Información general de los primitivos de sincronización.

La WaitHandle propia clase es abstracta. Las clases derivadas de WaitHandle definen un mecanismo de señalización para indicar que toman o liberan el acceso a un recurso compartido, pero usan los métodos heredados WaitHandle para bloquear mientras esperan el acceso a los recursos compartidos. Las clases derivadas de WaitHandle incluyen:

• La clase Mutex. Consulte Exclusión mutua.

• La EventWaitHandle clase y sus clases derivadas, AutoResetEvent y ManualResetEvent.

• La clase Semaphore. Consulta Semáforo y SemáforoSlim.

Los subprocesos pueden bloquearse en un identificador de espera individual llamando al método WaitOnede instancia , que hereda por las clases derivadas de WaitHandle.

Las clases derivadas de WaitHandle difieren en su afinidad de subproceso. Los identificadores de espera de eventos (EventWaitHandle, AutoResetEventy ) y ManualResetEventlos semáforos no tienen afinidad de subproceso; cualquier subproceso puede indicar un identificador de espera de evento o semáforo. Las exclusiones mutuas, por otro lado, tienen afinidad de subproceso; El subproceso que posee una exclusión mutua debe liberarlo y se produce una excepción si un subproceso llama al ReleaseMutex método en una exclusión mutua que no posee.

Dado que la WaitHandle clase se deriva de MarshalByRefObject, estas clases se pueden usar para sincronizar las actividades de los subprocesos entre los límites del dominio de aplicación.

Además de sus clases derivadas, la WaitHandle clase tiene una serie de métodos estáticos que bloquean un subproceso hasta que uno o varios objetos de sincronización reciben una señal. Se incluyen los siguientes:

• SignalAndWait, que permite que un subproceso indique un identificador de espera y espere inmediatamente en otro.

• WaitAll, que permite que un subproceso espere hasta que todos los identificadores de espera de una matriz reciban una señal.

• WaitAny, que permite que un subproceso espere hasta que se haya señalado a cualquiera de los identificadores de espera especificados.

Las sobrecargas de estos métodos proporcionan intervalos de tiempo de espera para abandonar la espera y la oportunidad de salir de un contexto de sincronización antes de entrar en la espera, lo que permite que otros subprocesos usen el contexto de sincronización.

Importante

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de usar el tipo o un tipo derivado de él, debe eliminarlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Close en un bloque try/catch. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.

WaitHandle implementa el Dispose patrón . Consulte Implementación de un método Dispose. Cuando derive de WaitHandle, use la propiedad para almacenar el SafeWaitHandle identificador del sistema operativo nativo. No es necesario invalidar el método protegido Dispose a menos que use recursos adicionales no administrados.

Constructores

WaitHandle()

Inicializa una nueva instancia de la clase WaitHandle.

Campos

InvalidHandle	Representa un identificador del sistema operativo nativo no válido. Este campo es de solo lectura.
WaitTimeout	Indica que una operación WaitAny(WaitHandle[], Int32, Boolean) ha superado el tiempo de espera antes de que se señalara un identificador de espera. Este campo es constante.

Propiedades

Handle	Obsoletos. Obtiene o establece el identificador del sistema operativo nativo.
SafeWaitHandle	Obtiene o establece el identificador del sistema operativo nativo.

Métodos

Close()	Libera todos los recursos mantenidos por el objeto WaitHandle actual.
CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos usados por la instancia actual de la clase WaitHandle.
Dispose(Boolean)	Cuando se reemplaza en una clase derivada, libera los recursos no administrados que usa WaitHandle y, de forma opcional, libera los recursos administrados.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la 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 Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)	Señala un WaitHandle y espera en otro.
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Señala un WaitHandle y espera en otro, para lo que determina un intervalo de tiempo de espera como entero con signo de 32 bits y especifica si se sale del dominio de sincronización para el contexto antes de entrar en la espera.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Señala un WaitHandle y espera en otro, para lo que determina el intervalo de tiempo de espera como TimeSpan y especifica si se sale del dominio de sincronización para el contexto antes de entrar en la espera.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
WaitAll(WaitHandle[])	Espera a que todos los elementos de la matriz especificada reciban una señal.
WaitAll(WaitHandle[], Int32)	Espera a que todos los elementos de la matriz especificada reciban una señal mediante un valor Int32 para especificar el intervalo de tiempo.
WaitAll(WaitHandle[], Int32, Boolean)	Espera a que todos los elementos de la matriz especificada reciban una señal; usa un valor Int32 para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de finalizar la espera.
WaitAll(WaitHandle[], TimeSpan)	Espera a que todos los elementos de la matriz especificada reciban una señal, usando un valor TimeSpan para especificar el intervalo de tiempo.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Espera a que todos los elementos de la matriz especificada reciban una señal; usa un valor TimeSpan para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de finalizar la espera.
WaitAny(WaitHandle[])	Espera a que cualquiera de los elementos de la matriz especificada reciba una señal.
WaitAny(WaitHandle[], Int32)	Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo.
WaitAny(WaitHandle[], Int32, Boolean)	Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; utiliza un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.
WaitAny(WaitHandle[], TimeSpan)	Espera a que cualquiera de los elementos de la matriz especificada reciba una señal, usando un TimeSpan para especificar el intervalo de tiempo.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Espera a que cualquiera de los elementos de la matriz especificada reciba una señal; usa un TimeSpan para especificar el intervalo de tiempo y especifica si se va a salir del dominio de sincronización antes de la espera.
WaitOne()	Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.
WaitOne(Int32)	Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usando un entero de 32 bits con signo para especificar el intervalo de tiempo en milisegundos.
WaitOne(Int32, Boolean)	Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usa un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si hay que salir del dominio de sincronización antes de la espera.
WaitOne(TimeSpan)	Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo.
WaitOne(TimeSpan, Boolean)	Bloquea el subproceso actual hasta que la instancia actual recibe una señal; usa TimeSpan para determinar el intervalo de tiempo y especifica si hay que abandonar el dominio de sincronización antes de la espera.

Métodos de extensión

GetSafeWaitHandle(WaitHandle)	Obtiene el controlador seguro para un identificador de espera del sistema operativo nativo.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Establece un controlador seguro para un identificador de espera del sistema operativo nativo.

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también

• Subprocesamiento
• Objetos y características de subprocesos
• Mutexes (Clases Mutex)
• EventWaitHandle, AutoResetEvent y ManualResetEvent
• Semáforos