WaitHandle Clase

Definición

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

Object

WaitHandle

Herencia

Object

MarshalByRefObject

WaitHandle

Derivado

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Atributos

ComVisibleAttribute

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.

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

Campos

Propiedades

Métodos

Implementaciones de interfaz explícitas

Métodos de extensión

Se aplica a

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