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

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

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

Un thread attend un signal en appelant AutoResetEvent.WaitOne. Si le AutoResetEvent est dans l’état non signalé, le thread se bloque jusqu’à AutoResetEvent.Set est appelé. Appeler Set signaux AutoResetEvent pour libérer un thread en attente. AutoResetEvent reste signalé jusqu’à ce que 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 le AutoResetEvent passe dans 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 le thread et retourne à l’état non signalé.

Important

Il n’existe aucune garantie que chaque appel à la méthode Set 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 Set est appelée lorsqu’il n’y a pas de threads en attente et que la AutoResetEvent est déjà signalée, l’appel n’a aucun effet.

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

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

AutoResetEvent dérive de la classe EventWaitHandle. Une AutoResetEvent est fonctionnellement équivalente à une EventWaitHandle créée avec EventResetMode.AutoReset.

Note

Contrairement à la classe AutoResetEvent, la classe EventWaitHandle 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 le type directement, appelez sa méthode Dispose dans un bloc try/catch. Pour le 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

AutoResetEvent(Boolean)

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

Champs

WaitTimeout

Indique qu’une opération de WaitAny(WaitHandle[], Int32, Boolean) a expiré avant que les handles d’attente n’aient été signalés. 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 WaitHandleactuel. (Hérité de WaitHandle)
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour 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 le WaitHandleet 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é du contrôle d’accès pour l’événement système nommé représenté par l’objet EventWaitHandle actuel. (Hérité de EventWaitHandle)
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 MarshalByRefObject actuel. (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)
SetAccessControl(EventWaitHandleSecurity)	Définit la sécurité du 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, à l’aide d’un entier signé 32 bits pour spécifier l’intervalle de temps en millisecondes. (Hérité de WaitHandle)
WaitOne(Int32, Boolean)	Bloque le thread actuel jusqu’à ce que le WaitHandle actuel 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(TimeSpan)	Bloque le thread actuel jusqu’à ce que l’instance actuelle reçoive un signal, à l’aide d’un 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, à l’aide d’un TimeSpan 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)

Méthodes d’extension

GetAccessControl(EventWaitHandle)	Retourne les descripteurs de sécurité pour le handlespécifié.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Définit les descripteurs de sécurité pour le handle d’attente d’événement spécifié.
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

Cette classe est thread safe.

Voir aussi

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