WaitHandle Classe

Definição

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

Herança

Object

WaitHandle

Herança

Object

MarshalByRefObject

WaitHandle

Derivado

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Atributos

ComVisibleAttribute

Implementações

IDisposable

Exemplos

O exemplo de código seguinte mostra como dois threads podem realizar tarefas em segundo plano enquanto o thread principal espera que as tarefas sejam concluídas, usando o static WaitAny e WaitAll os métodos da WaitHandle classe.

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

Observações

A WaitHandle classe encapsula um handle nativo de sincronização do sistema operativo e é usada para representar todos os objetos de sincronização no runtime que permitem múltiplas operações de espera. Para uma comparação entre os handles de espera com outros objetos de sincronização, veja Visão Geral das Primitivas de Sincronização.

A WaitHandle própria classe é abstrata. As classes derivadas de WaitHandle definem um mecanismo de sinalização para indicar a tomada ou libertação do acesso a um recurso partilhado, mas usam os métodos herdados WaitHandle para bloquear enquanto se espera acesso a recursos partilhados. As classes derivadas incluem WaitHandle :

• A Mutex classe. Ver Mutexes.

• A EventWaitHandle classe e as suas classes derivadas, AutoResetEvent e ManualResetEvent.

• A Semaphore classe. Veja Semáforo e Semáforo Slim.

Os threads podem bloquear num handle de espera individual chamando o método WaitOnede instância , que é herdado por classes derivadas de WaitHandle.

As classes derivadas de WaitHandle diferem na sua afinidade por threads. Handles de espera de eventos (EventWaitHandle, AutoResetEvent, e ManualResetEvent) e semáforos não têm afinidade de thread; qualquer thread pode sinalizar um handle de espera de evento ou semáforo. Os mutexes, por outro lado, têm afinidade por fios; O thread que possui um mutex deve libertá-lo, e uma exceção é lançada se um thread chamar o ReleaseMutex método num mutex que não possui.

Como a WaitHandle classe deriva de MarshalByRefObject, estas classes podem ser usadas para sincronizar as atividades dos threads através dos limites do domínio da aplicação.

Para além das suas classes derivadas, a WaitHandle classe possui vários métodos estáticos que bloqueiam um thread até que um ou mais objetos de sincronização recebam um sinal. Estes são, entre outros:

• SignalAndWait, que permite que um thread sinalize uma alça de espera e aguarde imediatamente noutra.

• WaitAll, o que permite que um thread espere até que todos os handles de espera num array recebam um sinal.

• WaitAny, o que permite que um thread espere até que qualquer um de um conjunto especificado de handles de espera seja sinalizado.

As sobrecargas destes métodos fornecem intervalos de timeout para abandonar a espera e a oportunidade de sair de um contexto de sincronização antes de entrar na espera, permitindo que outros threads usem o contexto de sincronização.

WaitHandle implementa o Dispose padrão. Veja Implementar um método de Eliminação. Quando derivar de WaitHandle, use a SafeWaitHandle propriedade para armazenar o seu handle nativo do sistema operativo. Não precisa de sobrescrever o método protegido Dispose a menos que use recursos adicionais não geridos.

Segurança de Thread

Este tipo é seguro para fios.

Ver também

• Encadeamento
• Encadeamento de objetos e funcionalidades
• Mutexes
• EventWaitHandle, AutoResetEvent e ManualResetEvent
• Semáforos