WaitHandle Clase

Definición

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

public ref class WaitHandle abstract : IDisposable
public ref class WaitHandle abstract : MarshalByRefObject, IDisposable
public abstract class WaitHandle : IDisposable
public abstract class WaitHandle : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable
type WaitHandle = class
    interface IDisposable
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
Public MustInherit Class WaitHandle
Implements IDisposable
Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable
Herencia
WaitHandle
Herencia
Derivado
Atributos
Implementaciones

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 se completen las tareas mediante los métodos estáticos WaitAny y de la clase WaitAll WaitHandle .

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 tasks are 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 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 WaitHandle 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 las primitivas de sincronización.

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

Los subprocesos pueden bloquear en un identificador de espera individual llamando al método de instancia , que se WaitOne hereda mediante clases derivadas de WaitHandle .

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

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

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

  • SignalAndWait, que permite a un subproceso señalar un identificador de espera y esperar 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 señale a cualquiera de un conjunto especificado de identificadores de espera.

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 desecharlo 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 . Vea Implementar un método Dispose. Cuando derive de WaitHandle , use la propiedad para almacenar el identificador del sistema operativo SafeWaitHandle nativo. No es necesario invalidar el método protegido a Dispose menos que use recursos no administrados adicionales.

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
Obsoleto.
Obsoleto.

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)
Finalize()

Libera los recursos mantenidos por la instancia actual.

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetLifetimeService()
Obsoleto.

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()
Obsoleto.

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.

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Esta API admite la infraestructura de producto y no está pensada para usarse directamente en el código.

Libera todos los recursos que usa WaitHandle.

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.

Se aplica a

Seguridad para subprocesos

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

Consulte también