WaitHandle Classe

Definizione

Incapsula oggetti specifici del sistema operativo che attendono l'accesso esclusivo alle risorse condivise.Encapsulates operating system-specific objects that wait for exclusive access to shared resources.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable
Ereditarietà
Derivato
Attributi
Implementazioni

Esempi

Nell'esempio di codice seguente viene illustrato come due thread possono eseguire attività in background mentre il thread principale attende il completamento delle attività usando i metodi statici WaitAny e WaitAll della classe WaitHandle.The following code example shows how two threads can do background tasks while the Main thread waits for the tasks to complete using the static WaitAny and WaitAll methods of the WaitHandle class.

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

Commenti

La classe WaitHandle incapsula un handle di sincronizzazione del sistema operativo nativo e viene usato per rappresentare tutti gli oggetti di sincronizzazione nel runtime che consentono più operazioni di attesa.The WaitHandle class encapsulates a native operating system synchronization handle and is used to represent all synchronization objects in the runtime that allow multiple wait operations. Per un confronto tra gli handle di attesa e gli altri oggetti di sincronizzazione, vedere Cenni preliminari sulle primitive di sincronizzazione.For a comparison of wait handles with other synchronization objects, see Overview of Synchronization Primitives.

La classe WaitHandle è astratta.The WaitHandle class itself is abstract. Le classi derivate da WaitHandle definiscono un meccanismo di segnalazione per indicare l'assunzione o il rilascio dell'accesso a una risorsa condivisa, ma usano i metodi WaitHandle ereditati per bloccare l'accesso alle risorse condivise.Classes derived from WaitHandle define a signaling mechanism to indicate taking or releasing access to a shared resource, but they use the inherited WaitHandle methods to block while waiting for access to shared resources. Le classi derivate da WaitHandle includono:The classes derived from WaitHandle include:

I thread possono bloccarsi su un handle di attesa singolo chiamando il metodo di istanza WaitOne, che viene ereditato dalle classi derivate da WaitHandle.Threads can block on an individual wait handle by calling the instance method WaitOne, which is inherited by classes derived from WaitHandle.

Le classi derivate di WaitHandle sono diverse nell'affinità di thread.The derived classes of WaitHandle differ in their thread affinity. Gli handle di attesa degli eventi (EventWaitHandle, AutoResetEvent e ManualResetEvent) e i semafori non presentano affinità di thread. qualsiasi thread può segnalare un semaforo o un handle di attesa di un evento.Event wait handles (EventWaitHandle, AutoResetEvent, and ManualResetEvent) and semaphores do not have thread affinity; any thread can signal an event wait handle or semaphore. I mutex, d'altra parte, presentano affinità di thread; il thread proprietario di un mutex deve rilasciarlo e viene generata un'eccezione se un thread chiama il metodo ReleaseMutex su un mutex di cui non è proprietario.Mutexes, on the other hand, do have thread affinity; the thread that owns a mutex must release it, and an exception is thrown if a thread calls the ReleaseMutex method on a mutex that it does not own.

Poiché la classe WaitHandle deriva da MarshalByRefObject, queste classi possono essere usate per sincronizzare le attività dei thread tra i limiti del dominio applicazione.Because the WaitHandle class derives from MarshalByRefObject, these classes can be used to synchronize the activities of threads across application domain boundaries.

Oltre alle classi derivate, la classe WaitHandle ha una serie di metodi statici che bloccano un thread finché uno o più oggetti di sincronizzazione non ricevono un segnale.In addition to its derived classes, the WaitHandle class has a number of static methods that block a thread until one or more synchronization objects receive a signal. Sono inclusi:These include:

  • SignalAndWait, che consente a un thread di segnalare un handle di attesa e di attendere immediatamente un altro.SignalAndWait, which allows a thread to signal one wait handle and immediately wait on another.

  • WaitAll, che consente a un thread di attendere che tutti gli handle di attesa in una matrice ricevano un segnale.WaitAll, which allows a thread to wait until all the wait handles in an array receive a signal.

  • WaitAny, che consente a un thread di attendere fino a quando non viene segnalato un set specificato di handle di attesa.WaitAny, which allows a thread to wait until any one of a specified set of wait handles has been signaled.

Gli overload di questi metodi forniscono intervalli di timeout per abbandonare l'attesa e l'opportunità di uscire da un contesto di sincronizzazione prima di immettere l'attesa, consentendo ad altri thread di usare il contesto di sincronizzazione.The overloads of these methods provide timeout intervals for abandoning the wait, and the opportunity to exit a synchronization context before entering the wait, allowing other threads to use the synchronization context.

Importante

Il tipo implementa l'interfaccia IDisposable.This type implements the IDisposable interface. Al termine dell'utilizzo del tipo o di un tipo derivato, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type or a type derived from it, you should dispose of it either directly or indirectly. Per eliminare direttamente il tipo, chiamare il metodo Close in un blocco try/catch.To dispose of the type directly, call its Close method in a try/catch block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

WaitHandle implementa il modello Dispose.WaitHandle implements the Dispose pattern. Vedere [implementazione di un metodo Dispose] (~/docs/standard/Garbage-Collection/Implementing-Dispose. MD).See [Implementing a Dispose method](~/docs/standard/garbage-collection/implementing-dispose .md). Quando si esegue la derivazione da WaitHandle, utilizzare la proprietà SafeWaitHandle per archiviare l'handle nativo del sistema operativo.When you derive from WaitHandle, use the SafeWaitHandle property to store your native operating system handle. Non è necessario eseguire l'override del metodo protetto Dispose, a meno che non si usino risorse non gestite aggiuntive.You do not need to override the protected Dispose method unless you use additional unmanaged resources.

Costruttori

WaitHandle()

Inizializza una nuova istanza della classe WaitHandle.Initializes a new instance of the WaitHandle class.

Campi

InvalidHandle

Rappresenta un handle nativo del sistema operativo non valido.Represents an invalid native operating system handle. Questo campo è di sola lettura.This field is read-only.

WaitTimeout

Indica che si è verificato il timeout di un'operazione WaitAny(WaitHandle[], Int32, Boolean) prima della segnalazione di uno degli handle di attesa.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Questo campo è costante.This field is constant.

Proprietà

Handle

Ottiene o imposta l'handle nativo del sistema operativo.Gets or sets the native operating system handle.

SafeWaitHandle

Ottiene o imposta l'handle nativo del sistema operativo.Gets or sets the native operating system handle.

Metodi

Close()

Rilascia tutte le risorse contenute nell'oggetto WaitHandle corrente.Releases all resources held by the current WaitHandle.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Ereditato da MarshalByRefObject)
Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

Dispose(Boolean)

Quando ne viene eseguito l'override in una classe derivata, libera le risorse non gestite usate da WaitHandle ed eventualmente di liberare le risorse gestite.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Finalize()

Rilascia le risorse contenute nell'istanza corrente.Releases the resources held by the current instance.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)

Segnala un oggetto WaitHandle e resta in attesa in un altro.Signals one WaitHandle and waits on another.

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Segnala un oggetto WaitHandle e resta in attesa in un altro, specificando un intervallo di timeout come intero con segno a 32 bit e indicando se uscire dal dominio di sincronizzazione per il contesto prima dell'attesa.Signals one WaitHandle and waits on another, specifying a time-out interval as a 32-bit signed integer and specifying whether to exit the synchronization domain for the context before entering the wait.

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Segnala un oggetto WaitHandle e resta in attesa di un altro, specificando l'intervallo di timeout come TimeSpan e indicando se uscire dal dominio di sincronizzazione per il contesto prima dell'attesa.Signals one WaitHandle and waits on another, specifying the time-out interval as a TimeSpan and specifying whether to exit the synchronization domain for the context before entering the wait.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
WaitAll(WaitHandle[])

Attende che tutti gli elementi nella matrice specificata ricevano un segnale.Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], Int32)

Attende che tutti gli elementi nella matrice specificata ricevano un segnale, usando un valore Int32 per specificare l'intervallo di tempo.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

WaitAll(WaitHandle[], Int32, Boolean)

Attende che tutti gli elementi nella matrice specificata ricevano un segnale, usando un valore Int32 per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], TimeSpan)

Attende che tutti gli elementi nella matrice specificata ricevano un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Attende che tutti gli elementi nella matrice specificata ricevano un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[])

Attende che uno degli elementi nella matrice specificata riceva un segnale.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval.

WaitAny(WaitHandle[], Int32, Boolean)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[], TimeSpan)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval.

WaitAny(WaitHandle[], TimeSpan, Boolean)

Attende che uno degli elementi nella matrice specificata riceva un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne()

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale.Blocks the current thread until the current WaitHandle receives a signal.

WaitOne(Int32)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

WaitOne(Int32, Boolean)

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne(TimeSpan)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

WaitOne(TimeSpan, Boolean)

Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un oggetto TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Rilascia tutte le risorse usate da WaitHandle.Releases all resources used by the WaitHandle.

Metodi di estensione

GetSafeWaitHandle(WaitHandle)

Ottiene l'handle sicuro per un handle di attesa nativo del sistema operativo.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Imposta un handle sicuro per un handle di attesa nativo del sistema operativo.Sets a safe handle for a native operating system wait handle.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche