WaitHandle Classe

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

WaitHandle.cs

Encapsule des objets spécifiques au système d’exploitation qui attendent un accès exclusif aux ressources partagées.

public ref class WaitHandle abstract : MarshalByRefObject, IDisposable

public abstract class WaitHandle : MarshalByRefObject, IDisposable

type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable

Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable

Héritage

Object

MarshalByRefObject

WaitHandle

Dérivé

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

Implémente

IDisposable

Exemples

L’exemple de code suivant montre comment deux threads peuvent effectuer des tâches en arrière-plan pendant que le thread principal attend que les tâches se terminent à l’aide des méthodes et WaitAll statiques WaitAny de la 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).

Remarques

La WaitHandle classe encapsule un handle de synchronisation de système d’exploitation natif et est utilisée pour représenter tous les objets de synchronisation dans le runtime qui autorisent plusieurs opérations d’attente. Pour obtenir une comparaison des handles d’attente avec d’autres objets de synchronisation, consultez Vue d’ensemble des primitives de synchronisation.

La WaitHandle classe elle-même est abstraite. Les classes dérivées de WaitHandle définir un mécanisme de signalisation pour indiquer la prise ou la libération de l’accès à une ressource partagée, mais elles utilisent les méthodes héritées WaitHandle pour bloquer tout en attendant l’accès aux ressources partagées. Les classes dérivées de WaitHandle :

• Classe Mutex . Voir Mutexes.

• La EventWaitHandle classe et ses classes dérivées, AutoResetEvent et ManualResetEvent.

• Classe Semaphore . Voir sémaphore et sémaphoreSlim.

Les threads peuvent bloquer sur un handle d’attente individuel en appelant la méthode WaitOned’instance, qui est héritée par les classes dérivées de WaitHandle.

Les classes dérivées de WaitHandle différences dans leur affinité de thread. Les handles d’attente d’événement (EventWaitHandle, AutoResetEventet ) et ManualResetEventles sémaphores n’ont pas d’affinité de thread ; tout thread peut signaler un handle d’attente d’événement ou un sémaphore. Les mutex, d’autre part, ont une affinité de thread ; le thread propriétaire d’un mutex doit le libérer et une exception est levée si un thread appelle la ReleaseMutex méthode sur un mutex qu’il ne possède pas.

Étant donné que la WaitHandle classe dérive de MarshalByRefObject, ces classes peuvent être utilisées pour synchroniser les activités des threads entre les limites du domaine d’application.

En plus de ses classes dérivées, la WaitHandle classe a un certain nombre de méthodes statiques qui bloquent un thread jusqu’à ce qu’un ou plusieurs objets de synchronisation reçoivent un signal. Voici quelques-uns des éléments suivants :

• SignalAndWait, qui permet à un thread de signaler une poignée d’attente et d’attendre immédiatement sur une autre.

• WaitAll, qui permet à un thread d’attendre que tous les handles d’attente d’un tableau reçoivent un signal.

• WaitAny, qui permet à un thread d’attendre jusqu’à ce qu’un ensemble de handles d’attente spécifié ait été signalé.

Les surcharges de ces méthodes fournissent des intervalles de délai d’attente pour abandonner l’attente et la possibilité de quitter un contexte de synchronisation avant d’entrer dans l’attente, ce qui permet à d’autres threads d’utiliser le contexte de synchronisation.

Important

Ce type implémente l’interface IDisposable . Lorsque vous avez fini d’utiliser le type ou un type dérivé de celui-ci, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type, appelez sa Close méthode dans un try/catch bloc. Pour la supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet implémentant IDisposable » dans la rubrique d’interface IDisposable .

WaitHandle implémente le Dispose modèle. Consultez Implémentation d’une méthode Dispose. Lorsque vous dérivez de WaitHandle, utilisez la SafeWaitHandle propriété pour stocker votre handle de système d’exploitation natif. Vous n’avez pas besoin de remplacer la méthode protégée Dispose , sauf si vous utilisez des ressources non managées supplémentaires.

Constructeurs

Nom	Description
WaitHandle()	Initialise une nouvelle instance de la classe WaitHandle.

Champs

Nom	Description
InvalidHandle	Représente un handle de système d’exploitation natif non valide. Ce champ est en lecture seule.
WaitTimeout	Indique qu’une WaitAny(WaitHandle[], Int32, Boolean) opération a expiré avant que les handles d’attente n’aient été signalés. Ce champ est constant.

Propriétés

Nom	Description
Handle	Obsolète. Obtient ou définit le handle du système d’exploitation natif.
SafeWaitHandle	Obtient ou définit le handle du système d’exploitation natif.

Méthodes

Nom	Description
Close()	Libère toutes les ressources détenues par le fichier actif WaitHandle.
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la WaitHandle classe.
Dispose(Boolean)	En cas de substitution dans une classe dérivée, libère les ressources non managées utilisées par le WaitHandle, et libère éventuellement les ressources managées.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet actuel MarshalByRefObject . (Hérité de MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)	Signale l’un WaitHandle et attend sur un autre, en spécifiant un intervalle de délai d’attente sous la forme d’un entier signé 32 bits et en spécifiant s’il faut quitter le domaine de synchronisation pour le contexte avant d’entrer l’attente.
SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)	Signale l’un WaitHandleTimeSpan et attend sur un autre, en spécifiant l’intervalle de délai d’attente en tant que domaine de synchronisation et en spécifiant s’il faut quitter le domaine de synchronisation pour le contexte avant d’entrer l’attente.
SignalAndWait(WaitHandle, WaitHandle)	Signale l’un WaitHandle et attend sur un autre.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
WaitAll(WaitHandle[], Int32, Boolean)	Attend que tous les éléments du tableau spécifié reçoivent un signal, en utilisant une Int32 valeur pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.
WaitAll(WaitHandle[], Int32)	Attend que tous les éléments du tableau spécifié reçoivent un signal, en utilisant une Int32 valeur pour spécifier l’intervalle de temps.
WaitAll(WaitHandle[], TimeSpan, Boolean)	Attend que tous les éléments du tableau spécifié reçoivent un signal, en utilisant une TimeSpan valeur pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.
WaitAll(WaitHandle[], TimeSpan)	Attend que tous les éléments du tableau spécifié reçoivent un signal, en utilisant une TimeSpan valeur pour spécifier l’intervalle de temps.
WaitAll(WaitHandle[])	Attend que tous les éléments du tableau spécifié reçoivent un signal.
WaitAny(WaitHandle[], Int32, Boolean)	Attend que l’un des éléments du tableau spécifié reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.
WaitAny(WaitHandle[], Int32)	Attend que l’un des éléments du tableau spécifié reçoive un signal, à l’aide d’un entier signé 32 bits pour spécifier l’intervalle de temps.
WaitAny(WaitHandle[], TimeSpan, Boolean)	Attend que l’un des éléments du tableau spécifié reçoive un signal, en utilisant un TimeSpan pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.
WaitAny(WaitHandle[], TimeSpan)	Attend que l’un des éléments du tableau spécifié reçoive un signal, en utilisant un TimeSpan pour spécifier l’intervalle de temps.
WaitAny(WaitHandle[])	Attend que l’un des éléments du tableau spécifié reçoive un signal.
WaitOne()	Bloque le thread actuel jusqu’à ce que le courant WaitHandle reçoive un signal.
WaitOne(Int32, Boolean)	Bloque le thread actuel jusqu’à ce que le courant WaitHandle reçoive un signal, à l’aide d’un entier signé 32 bits pour spécifier l’intervalle de temps et spécifier s’il faut quitter le domaine de synchronisation avant l’attente.
WaitOne(Int32)	Bloque le thread actuel jusqu’à ce que le courant WaitHandle reçoive un signal, à l’aide d’un entier signé 32 bits pour spécifier l’intervalle de temps en millisecondes.
WaitOne(TimeSpan, Boolean)	Bloque le thread actuel jusqu’à ce que l’instance actuelle reçoive un signal, en utilisant un TimeSpan pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.
WaitOne(TimeSpan)	Bloque le thread actuel jusqu’à ce que l’instance actuelle reçoive un signal, en utilisant un TimeSpan pour spécifier l’intervalle de temps.

Méthodes d’extension

Nom	Description
GetSafeWaitHandle(WaitHandle)	Obtient le handle sécurisé pour un handle d’attente du système d’exploitation natif.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Définit un handle sécurisé pour un handle d’attente du système d’exploitation natif.

Cohérence de thread

Ce type est thread safe.

Voir aussi

• Filetage
• Objets et fonctionnalités de gestion des threads
• Mutex
• EventWaitHandle, AutoResetEvent et ManualResetEvent
• Sémaphores