AutoResetEvent Classe

Définition

Espace de noms:

System.Threading

Assembly:

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 se 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 un AutoResetEvent qui a été créé à l’état signalé. Le premier thread est libéré immédiatement, car le AutoResetEvent est déjà à l’état signalé. Cela rétablit le AutoResetEvent à l’état non signalé, de sorte que les threads suivants se bloquent. Les threads bloqués ne sont pas libérés tant que l’utilisateur ne les libère pas un par un en appuyant sur la touche Entrée .

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

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    static AutoResetEvent^ event_1 = gcnew AutoResetEvent(true);
    static AutoResetEvent^ event_2 = gcnew AutoResetEvent(false);

    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);
    }

public:
    static void Demo()
    {
        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 = gcnew Thread(gcnew ThreadStart(&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();
    }
};

void main()
{
    Example::Demo();
}

/* 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.
 */

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 est AutoResetEvent à l’état non 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 Reset que soit appelé ou qu’un seul thread en attente soit libéré, à quel moment il revient automatiquement à l’état non signalé.

Si aucun thread n’attend quand le AutoResetEvent passe à un état signalé, l’état reste signalé jusqu’à ce qu’un thread observe le signal (en appelant WaitOne). Ce thread ne bloque pas : le AutoResetEvent 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 l’un de l’autre, de sorte que le deuxième appel se produit avant la libération d’un thread, un seul thread est libéré. C’est comme si le deuxième appel n’avait pas eu lieu. En outre, si Set est appelé quand aucun thread n’est en attente et que le 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.

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

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

Notes

Contrairement à la AutoResetEvent classe , la classe fournit l’accès EventWaitHandle 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 Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » sur la page de l’interface IDisposable .

Constructeurs

AutoResetEvent(Boolean)

Initialise une nouvelle instance de la classe AutoResetEvent avec une valeur booléenne indiquant si l'état initial doit être défini comme signalé.

Champs

WaitTimeout

Indique que le délai fixé pour une opération WaitAny(WaitHandle[], Int32, Boolean) a été dépassé sans qu'aucun des handles d'attente n'ait été signalé. Ce champ est constant. (Hérité de WaitHandle)

Propriétés

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

Close()	Libère toutes les ressources détenues par le WaitHandle actuel. (Hérité de WaitHandle)
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Dispose()	Libère toutes les ressources utilisées par l'instance actuelle de la classe WaitHandle. (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 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)
GetAccessControl()	Obtient un objet EventWaitHandleSecurity qui représente la sécurité de contrôle d'accès pour l'événement système nommé représenté par l'objet EventWaitHandle actuel. (Hérité de EventWaitHandle)
GetHashCode()	Fait office 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 en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetType()	Obtient le 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 Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
Reset()	Définit l'état de l'événement comme étant non signalé, entraînant le blocage des threads. (Hérité de EventWaitHandle)
Set()	Définit l'état de l'événement comme étant signalé, ce qui permet à un ou plusieurs threads en attente de continuer. (Hérité de EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Définit la sécurité de contrôle d’accès pour un événement système nommé. (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 WaitHandle actuel reçoive un signal. (Hérité de WaitHandle)
WaitOne(Int32)	Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps. (Hérité de WaitHandle)
WaitOne(Int32, Boolean)	Bloque le thread actuel jusqu’à ce que le WaitHandle actuel 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. (Hérité de WaitHandle)
WaitOne(TimeSpan)	Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps. (Hérité de WaitHandle)
WaitOne(TimeSpan, Boolean)	Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur 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)

Méthodes d’extension

GetSafeWaitHandle(WaitHandle)	Obtient le handle sécurisé pour un handle d’attente de système d’exploitation natif.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Définit un handle sécurisé pour un handle d’attente de 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