WaitHandle Classe

Definizione

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

Ereditarietà

Object

WaitHandle

Ereditarietà

Object

MarshalByRefObject

WaitHandle

Derivato

System.Threading.AutoResetEvent

System.Threading.EventWaitHandle

System.Threading.ManualResetEvent

System.Threading.Mutex

System.Threading.Semaphore

Attributi

ComVisibleAttribute

Implementazioni

IDisposable

Esempio

Nell'esempio di codice seguente viene illustrato come due thread possono eseguire attività in background mentre il thread Main attende il completamento delle attività usando i metodi e WaitAll statici WaitAny della WaitHandle classe .

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

Commenti

La WaitHandle classe incapsula un handle di sincronizzazione del sistema operativo nativo e viene usata per rappresentare tutti gli oggetti di sincronizzazione nel runtime che consentono più operazioni di attesa. Per un confronto degli handle di attesa con altri oggetti di sincronizzazione, vedere Panoramica delle primitive di sincronizzazione.

La WaitHandle classe stessa è astratta. Le classi derivate da WaitHandle definiscono un meccanismo di segnalazione per indicare l'acquisizione o il rilascio dell'accesso a una risorsa condivisa, ma usano i metodi ereditati WaitHandle per bloccare l'attesa dell'accesso alle risorse condivise. Le classi derivate da WaitHandle includono:

• Classe Mutex. Vedere Mutex.

• La EventWaitHandle classe e le AutoResetEvent relative classi derivate e ManualResetEvent.

• Classe Semaphore. Vedere Semaphore e SemaphoreSlim.

I thread possono bloccarsi in un singolo handle di attesa chiamando il metodo WaitOnedi istanza , ereditato dalle classi derivate da WaitHandle.

Le classi derivate di WaitHandle differiscono nell'affinità di thread. Gli handle di attesa degli eventi (EventWaitHandle, AutoResetEvente ) e ManualResetEventi semafori non hanno affinità di thread. Qualsiasi thread può segnalare un handle di attesa degli eventi o un semaforo. I mutex, d'altra parte, hanno affinità di thread; il thread proprietario di un mutex deve rilasciarlo e viene generata un'eccezione se un thread chiama il ReleaseMutex metodo su un mutex che non è proprietario.

Poiché la WaitHandle classe deriva da MarshalByRefObject, queste classi possono essere usate per sincronizzare le attività dei thread attraverso i limiti del dominio applicazione.

Oltre alle classi derivate, la WaitHandle classe dispone di diversi metodi statici che bloccano un thread fino a quando uno o più oggetti di sincronizzazione non ricevono un segnale. Sono inclusi:

• SignalAndWait, che consente a un thread di segnalare un handle di attesa e attendere immediatamente su un altro.

• WaitAll, che consente a un thread di attendere fino a quando tutti gli handle di attesa in una matrice ricevono un segnale.

• WaitAny, che consente a un thread di attendere fino a quando non viene segnalato uno dei set di handle di attesa specificati.

Gli overload di questi metodi forniscono intervalli di timeout per abbandonare l'attesa e la possibilità di uscire da un contesto di sincronizzazione prima di entrare nell'attesa, consentendo ad altri thread di usare il contesto di sincronizzazione.

WaitHandle implementa il Dispose modello. Vedere Implementazione di un metodo Dispose. Quando si deriva da WaitHandle, usare la proprietà per archiviare l'handle SafeWaitHandle del sistema operativo nativo. Non è necessario eseguire l'override del metodo protetto Dispose , a meno che non si usino risorse aggiuntive non gestite.

Costruttori

Campi

Proprietà

Metodi

Implementazioni dell'interfaccia esplicita

Metodi di estensione

Si applica a

Thread safety

Questo tipo è thread-safe.

Vedi anche

• Threading
• Oggetti e funzionalità del threading
• Mutex
• EventWaitHandle, AutoResetEvent e ManualResetEvent
• Semafori