AutoResetEvent Classe

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Threading.dll

Source:

AutoResetEvent.cs

Représente un événement de synchronisation de threads qui, lorsqu’il est signalé, libère un seul thread en attente, puis réinitialise automatiquement. Cette classe ne peut pas être héritée.

public ref class AutoResetEvent sealed : System::Threading::EventWaitHandle

public sealed class AutoResetEvent : System.Threading.EventWaitHandle

type AutoResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class AutoResetEvent
Inherits EventWaitHandle

Héritage

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

AutoResetEvent

Exemples

L’exemple suivant montre comment utiliser AutoResetEvent pour libérer un thread à la fois, en appelant la Set méthode (sur la classe de base) chaque fois que l’utilisateur appuie sur la touche Entrée . L’exemple démarre trois threads, qui attendent une AutoResetEvent création à l’état signalé. Le premier thread est libéré immédiatement, car il AutoResetEvent est déjà dans l’état signalé. Cela réinitialise l’état AutoResetEvent non signalé, afin que les threads suivants bloquent. Les threads bloqués ne sont pas libérés tant que l’utilisateur ne les relâche qu’un à la fois en appuyant sur la touche Entrée .

Une fois les threads libérés du premier AutoResetEvent, ils attendent sur un autre AutoResetEvent qui a été créé dans l’état non signalé. Les trois threads bloquent, de sorte que la Set méthode doit être appelée trois fois pour les libérer toutes.

using System;
using System.Threading;

// Visual Studio: Replace the default class in a Console project with 
//                the following class.
class Example
{
    private static AutoResetEvent event_1 = new AutoResetEvent(true);
    private static AutoResetEvent event_2 = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Press Enter to create three threads and start them.\r\n" +
                          "The threads wait on AutoResetEvent #1, which was created\r\n" +
                          "in the signaled state, so the first thread is released.\r\n" +
                          "This puts AutoResetEvent #1 into the unsignaled state.");
        Console.ReadLine();
            
        for (int i = 1; i < 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }
        Thread.Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine("Press Enter to release another thread.");
            Console.ReadLine();
            event_1.Set();
            Thread.Sleep(250);
        }

        Console.WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Press Enter to release a thread.");
            Console.ReadLine();
            event_2.Set();
            Thread.Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console.Readline();
    }

    static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console.WriteLine("{0} ends.", name);
    }
}

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */

Imports System.Threading

' Visual Studio: Replace the default class in a Console project with 
'                the following class.
Class Example

    Private Shared event_1 As New AutoResetEvent(True)
    Private Shared event_2 As New AutoResetEvent(False)

    <MTAThread()> _
    Shared Sub Main()
    
        Console.WriteLine("Press Enter to create three threads and start them." & vbCrLf & _
                          "The threads wait on AutoResetEvent #1, which was created" & vbCrLf & _
                          "in the signaled state, so the first thread is released." & vbCrLf & _
                          "This puts AutoResetEvent #1 into the unsignaled state.")
        Console.ReadLine()
            
        For i As Integer = 1 To 3
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next
        Thread.Sleep(250)

        For i As Integer = 1 To 2
            Console.WriteLine("Press Enter to release another thread.")
            Console.ReadLine()

            event_1.Set()
            Thread.Sleep(250)
        Next

        Console.WriteLine(vbCrLf & "All threads are now waiting on AutoResetEvent #2.")
        For i As Integer = 1 To 3
            Console.WriteLine("Press Enter to release a thread.")
            Console.ReadLine()

            event_2.Set()
            Thread.Sleep(250)
        Next

        ' Visual Studio: Uncomment the following line.
        'Console.Readline()
    End Sub

    Shared Sub ThreadProc()
    
        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name)
        event_1.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name)

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name)
        event_2.WaitOne()
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name)

        Console.WriteLine("{0} ends.", name)
    End Sub
End Class

' This example produces output similar to the following:
'
'Press Enter to create three threads and start them.
'The threads wait on AutoResetEvent #1, which was created
'in the signaled state, so the first thread is released.
'This puts AutoResetEvent #1 into the unsignaled state.
'
'Thread_1 waits on AutoResetEvent #1.
'Thread_1 is released from AutoResetEvent #1.
'Thread_1 waits on AutoResetEvent #2.
'Thread_3 waits on AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #1.
'Press Enter to release another thread.
'
'Thread_3 is released from AutoResetEvent #1.
'Thread_3 waits on AutoResetEvent #2.
'Press Enter to release another thread.
'
'Thread_2 is released from AutoResetEvent #1.
'Thread_2 waits on AutoResetEvent #2.
'
'All threads are now waiting on AutoResetEvent #2.
'Press Enter to release a thread.
'
'Thread_2 is released from AutoResetEvent #2.
'Thread_2 ends.
'Press Enter to release a thread.
'
'Thread_1 is released from AutoResetEvent #2.
'Thread_1 ends.
'Press Enter to release a thread.
'
'Thread_3 is released from AutoResetEvent #2.
'Thread_3 ends.

Remarques

Vous utilisez AutoResetEvent, ManualResetEventet EventWaitHandle pour l’interaction de thread (ou la signalisation de thread). Pour plus d’informations, consultez Interaction de thread.

Un thread attend un signal en appelant AutoResetEvent.WaitOne. Si l’état AutoResetEvent n’est pas signalé, le thread se bloque jusqu’à ce que AutoResetEvent.Set soit appelé. Appel de Set signaux AutoResetEvent pour libérer un thread en attente. AutoResetEvent reste signalé jusqu’à ce qu’il Reset soit appelé ou qu’un thread en attente unique soit libéré, auquel moment il revient automatiquement à l’état non signalé.

Si aucun thread n’attend lorsque l’état AutoResetEvent est signalé, l’état reste signalé jusqu’à ce qu’un thread observe le signal (en appelant WaitOne). Ce thread ne bloque pas : le AutoResetEvent thread libère immédiatement et retourne à l’état non signalé.

Important

Il n’existe aucune garantie que chaque appel à la Set méthode libère un thread. Si deux appels sont trop proches, de sorte que le deuxième appel se produit avant la publication d’un thread, un seul thread est libéré. C’est comme si le deuxième appel n’a pas eu lieu. En outre, si elle Set est appelée lorsqu’il n’y a pas de threads en attente et que l’appel AutoResetEvent est déjà signalé, l’appel n’a aucun effet.

Vous pouvez contrôler l’état initial d’un en AutoResetEvent passant une valeur booléenne au constructeur : true si l’état initial est signalé et false sinon.

AutoResetEventpeut également être utilisé avec les méthodes et WaitAny les staticWaitAll méthodes.

AutoResetEvent dérive de la EventWaitHandle classe. Un AutoResetEvent est fonctionnellement équivalent à un EventWaitHandle élément créé avec EventResetMode.AutoReset.

Note

Contrairement à la AutoResetEvent classe, la EventWaitHandle classe fournit l’accès aux événements de synchronisation système nommés.

Important

Ce type implémente l’interface IDisposable . Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type, appelez sa Dispose 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 page d’interface IDisposable .

Constructeurs

Nom	Description
AutoResetEvent(Boolean)	Initialise une nouvelle instance de la AutoResetEvent classe avec une valeur booléenne indiquant s’il faut définir l’état initial à signaler.

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 é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)
Reset()	Définit l’état de l’événement sur non signé, ce qui entraîne le blocage des threads. (Hérité de EventWaitHandle)
Set()	Définit l’état de l’événement à signaler, ce qui permet à un ou plusieurs threads en attente de continuer. (Hérité de EventWaitHandle)
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
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

Cette classe est thread safe.

Voir aussi

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