EventWaitHandle Classe

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Threading.dll

Source:

EventWaitHandle.cs

Représente un événement de synchronisation de threads.

public ref class EventWaitHandle : System::Threading::WaitHandle

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Héritage

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Dérivé

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Exemples

L’exemple de code suivant utilise la SignalAndWait(WaitHandle, WaitHandle) surcharge de méthode pour autoriser le thread principal à signaler un thread bloqué, puis attendre que le thread termine une tâche.

L’exemple démarre cinq threads et les permet de bloquer sur un EventWaitHandle thread créé avec l’indicateur EventResetMode.AutoReset , puis libère un thread chaque fois que l’utilisateur appuie sur la touche Entrée . L’exemple met ensuite en file d’attente cinq threads et les libère tous à l’aide d’un EventWaitHandle thread créé avec l’indicateur EventResetMode.ManualReset .

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();
    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Imports System.Threading

Public Class Example

    ' The EventWaitHandle used to demonstrate the difference
    ' between AutoReset and ManualReset synchronization events.
    '
    Private Shared ewh As EventWaitHandle

    ' A counter to make sure all threads are started and
    ' blocked before any are released. A Long is used to show
    ' the use of the 64-bit Interlocked methods.
    '
    Private Shared threadCount As Long = 0

    ' An AutoReset event that allows the main thread to block
    ' until an exiting thread has decremented the count.
    '
    Private Shared clearCount As New EventWaitHandle(False, _
        EventResetMode.AutoReset)

    <MTAThread> _
    Public Shared Sub Main()

        ' Create an AutoReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.AutoReset)

        ' Create and start five numbered threads. Use the
        ' ParameterizedThreadStart delegate, so the thread
        ' number can be passed as an argument to the Start 
        ' method.
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        ' When multiple threads use a 64-bit value on a 32-bit
        ' system, you must access the value through the
        ' Interlocked class to guarantee thread safety.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Release one thread each time the user presses ENTER,
        ' until all threads have been released.
        '
        While Interlocked.Read(threadCount) > 0
            Console.WriteLine("Press ENTER to release a waiting thread.")
            Console.ReadLine()

            ' SignalAndWait signals the EventWaitHandle, which
            ' releases exactly one thread before resetting, 
            ' because it was created with AutoReset mode. 
            ' SignalAndWait then blocks on clearCount, to 
            ' allow the signaled thread to decrement the count
            ' before looping again.
            '
            WaitHandle.SignalAndWait(ewh, clearCount)
        End While
        Console.WriteLine()

        ' Create a ManualReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.ManualReset)

        ' Create and start five more numbered threads.
        '
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Because the EventWaitHandle was created with
        ' ManualReset mode, signaling it releases all the
        ' waiting threads.
        '
        Console.WriteLine("Press ENTER to release the waiting threads.")
        Console.ReadLine()
        ewh.Set()
        
    End Sub

    Public Shared Sub ThreadProc(ByVal data As Object)
        Dim index As Integer = CInt(data)

        Console.WriteLine("Thread {0} blocks.", data)
        ' Increment the count of blocked threads.
        Interlocked.Increment(threadCount)

        ' Wait on the EventWaitHandle.
        ewh.WaitOne()

        Console.WriteLine("Thread {0} exits.", data)
        ' Decrement the count of blocked threads.
        Interlocked.Decrement(threadCount)

        ' After signaling ewh, the main thread blocks on
        ' clearCount until the signaled thread has 
        ' decremented the count. Signal it now.
        '
        clearCount.Set()
    End Sub
End Class

Remarques

La EventWaitHandle classe permet aux threads de communiquer entre eux en signalant. En règle générale, un ou plusieurs threads bloquent un EventWaitHandle thread jusqu’à ce qu’un thread déblocé appelle la Set méthode, en libérant un ou plusieurs des threads bloqués. Un thread peut signaler un EventWaitHandle, puis le bloquer, en appelant la méthode static (Shared dans Visual Basic) WaitHandle.SignalAndWait.

Note

La EventWaitHandle classe fournit l’accès aux événements de synchronisation système nommés.

Le comportement d’un EventWaitHandle signal signalé dépend de son mode de réinitialisation. Un EventWaitHandle indicateur créé avec l’indicateur EventResetMode.AutoReset est réinitialisé automatiquement lorsqu’il est signalé, après avoir libéré un seul thread en attente. Un EventWaitHandle créé avec l'indicateur EventResetMode.ManualReset reste activé jusqu'à ce que sa méthode Reset soit appelée.

Les événements de réinitialisation automatique fournissent un accès exclusif à une ressource. Si un événement à réinitialisation automatique est signalé alors qu’aucun thread n’attend, il reste signalé jusqu'à ce qu’un thread tente de l’attendre. L’événement libère le thread et réinitialise immédiatement, bloquant les threads suivants.

Les événements de réinitialisation manuelle sont comme des portes. Lorsque l’événement n’est pas signalé, les threads qui attendent qu’il se bloque. Lorsque l’événement est signalé, tous les threads en attente sont libérés et l’événement reste signalé (autrement dit, les attentes suivantes ne bloquent pas) tant que sa Reset méthode n’est pas appelée. Les événements de réinitialisation manuelle sont utiles lorsqu’un thread doit terminer une activité avant que d’autres threads puissent continuer.

les objets EventWaitHandle peuvent être utilisés avec les méthodes static(Shared dans Visual Basic) WaitHandle.WaitAll et WaitHandle.WaitAny.

Pour plus d’informations, consultez la section Interaction des threads ou signalisation de l’article Vue d’ensemble des primitives de synchronisation .

Avertissement

Par défaut, un événement nommé n’est pas limité à l’utilisateur qui l’a créé. D’autres utilisateurs peuvent être en mesure d’ouvrir et d’utiliser l’événement, y compris interférer avec l’événement en définissant ou en le réinitialisant de manière inappropriée. Pour restreindre l’accès à des utilisateurs spécifiques, vous pouvez utiliser une surcharge de constructeur ou EventWaitHandleAcl passer un EventWaitHandleSecurity lors de la création de l’événement nommé. Évitez d’utiliser des événements nommés sans restrictions d’accès sur les systèmes susceptibles d’avoir des utilisateurs non approuvés exécutant du code.

Constructeurs

Nom	Description
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Initialise une nouvelle instance de la EventWaitHandle classe, en spécifiant si le handle d’attente est initialement signalé s’il est créé à la suite de cet appel, s’il réinitialise automatiquement ou manuellement, le nom d’un événement de synchronisation système et une variable booléenne dont la valeur après l’appel indique si l’événement système nommé a été créé.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions, Boolean)	Initialise une nouvelle instance de la EventWaitHandle classe, en spécifiant si le handle d’attente est initialement signalé s’il est créé à la suite de cet appel, s’il réinitialise automatiquement ou manuellement, le nom d’un événement de synchronisation système, les options permettant de définir l’étendue utilisateur et l’accès à l’étendue de session et une variable booléenne dont la valeur après l’appel indique si l’événement système nommé a été créé.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions)	Initialise une nouvelle instance de la EventWaitHandle classe, en spécifiant si le handle d’attente est initialement signalé s’il est créé à la suite de cet appel, s’il réinitialise automatiquement ou manuellement, le nom d’un événement de synchronisation système et les options permettant de définir l’étendue utilisateur et l’accès à l’étendue de session.
EventWaitHandle(Boolean, EventResetMode, String)	Initialise une nouvelle instance de la EventWaitHandle classe, en spécifiant si le handle d’attente est initialement signalé s’il est créé à la suite de cet appel, s’il réinitialise automatiquement ou manuellement et le nom d’un événement de synchronisation système.
EventWaitHandle(Boolean, EventResetMode)	Initialise une nouvelle instance de la EventWaitHandle classe, en spécifiant si le handle d’attente est initialement signalé et s’il réinitialise automatiquement ou manuellement.

Champs

Nom	Description
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. (Hérité de WaitHandle)

Propriétés

Nom	Description
Handle	Obsolète. Obtient ou définit le handle du système d’exploitation natif. (Hérité de WaitHandle)
SafeWaitHandle	Obtient ou définit le handle du système d’exploitation natif. (Hérité de WaitHandle)

Méthodes

Nom	Description
Close()	Libère toutes les ressources détenues par le fichier actif WaitHandle. (Hérité de WaitHandle)
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la WaitHandle classe. (Hérité de WaitHandle)
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. (Hérité de WaitHandle)
Equals(Object)	Détermine si l'objet spécifié est identique à 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)
OpenExisting(String, NamedWaitHandleOptions)	Ouvre l’événement de synchronisation nommé spécifié, s’il existe déjà. Si les options sont définies sur l’utilisateur actuel uniquement, les contrôles d’accès de l’objet sont vérifiés pour l’utilisateur appelant.
OpenExisting(String)	Ouvre l’événement de synchronisation nommé spécifié, s’il existe déjà.
Reset()	Définit l’état de l’événement sur non signé, ce qui entraîne le blocage des threads.
Set()	Définit l’état de l’événement à signaler, ce qui permet à un ou plusieurs threads en attente de continuer.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TryOpenExisting(String, EventWaitHandle)	Ouvre l’événement de synchronisation nommé spécifié, s’il existe déjà, et retourne une valeur qui indique si l’opération a réussi.
TryOpenExisting(String, NamedWaitHandleOptions, EventWaitHandle)	Ouvre l’événement de synchronisation nommé spécifié, s’il existe déjà, et retourne une valeur qui indique si l’opération a réussi. Si les options sont définies sur l’utilisateur actuel uniquement, les contrôles d’accès de l’objet sont vérifiés pour l’utilisateur appelant.
WaitOne()	Bloque le thread actuel jusqu’à ce que le courant WaitHandle reçoive un signal. (Hérité de WaitHandle)
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. (Hérité de WaitHandle)
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. (Hérité de WaitHandle)
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. (Hérité de WaitHandle)
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. (Hérité de WaitHandle)

Méthodes d’extension

Nom	Description
GetAccessControl(EventWaitHandle)	Retourne les descripteurs de sécurité pour le .handle
GetSafeWaitHandle(WaitHandle)	Obtient le handle sécurisé pour un handle d’attente du système d’exploitation natif.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Définit les descripteurs de sécurité pour le handle d’attente d’événement spécifié.
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

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Threading managé
• Vue d’ensemble des primitives de synchronisation