AutoResetEvent Classe

Définition

Représente un événement de synchronisation de threads qui, quand il est signalé, se réinitialise automatiquement après avoir libéré un thread en attente.Represents a thread synchronization event that, when signaled, resets automatically after releasing a single waiting thread. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class AutoResetEvent sealed : System::Threading::EventWaitHandle
public ref class AutoResetEvent sealed : System::Threading::WaitHandle
public sealed class AutoResetEvent : System.Threading.EventWaitHandle
public sealed class AutoResetEvent : System.Threading.WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class AutoResetEvent : System.Threading.EventWaitHandle
type AutoResetEvent = class
    inherit EventWaitHandle
type AutoResetEvent = class
    inherit WaitHandle
[<System.Runtime.InteropServices.ComVisible(true)>]
type AutoResetEvent = class
    inherit EventWaitHandle
Public NotInheritable Class AutoResetEvent
Inherits EventWaitHandle
Public NotInheritable Class AutoResetEvent
Inherits WaitHandle
Héritage
Héritage
Héritage
Attributs

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 .The following example shows how to use AutoResetEvent to release one thread at a time, by calling the Set method (on the base class) each time the user presses the Enter key. L’exemple démarre trois threads, qui attendent sur un AutoResetEvent qui a été créé dans l’état signalé.The example starts three threads, which wait on an AutoResetEvent that was created in the signaled state. Le premier thread est libéré immédiatement, car le AutoResetEvent est déjà à l’état signalé.The first thread is released immediately, because the AutoResetEvent is already in the signaled state. Cela réinitialise le AutoResetEvent à l’état non signalé, afin que les threads suivants bloquent.This resets the AutoResetEvent to the non-signaled state, so that subsequent threads block. Les threads bloqués ne sont pas libérés tant que l’utilisateur ne les relâche pas un par un en appuyant sur la touche entrée .The blocked threads are not released until the user releases them one at a time by pressing the Enter key.

Une fois que les threads sont libérés du premier AutoResetEvent , ils attendent un autre AutoResetEvent qui a été créé dans l’état non signalé.After the threads are released from the first AutoResetEvent, they wait on another AutoResetEvent that was created in the non-signaled state. Les trois threads se bloquent Set . la méthode doit donc être appelée trois fois pour toutes les libérer.All three threads block, so the Set method must be called three times to release them all.

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 , ManualResetEvent et EventWaitHandle pour l’interaction de thread (ou la signalisation de thread).You use AutoResetEvent, ManualResetEvent, and EventWaitHandle for thread interaction (or thread signaling). Pour plus d’informations, consultez la section interaction des threads ou signalisation de l’article vue d’ensemble des primitives de synchronisation .For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Un thread attend un signal en appelant AutoResetEvent. WaitOne.A thread waits for a signal by calling AutoResetEvent.WaitOne. Si le AutoResetEvent est dans l’état non signalé, le thread se bloque jusqu’à ce que AutoResetEvent. Set soit appelé.If the AutoResetEvent is in the non-signaled state, the thread blocks until AutoResetEvent.Set is called.

Appel Set AutoResetEvent de signaux pour libérer un thread en attente.Calling Set signals AutoResetEvent to release a waiting thread. AutoResetEvent reste signalé jusqu’à ce qu’un seul thread en attente soit libéré, puis retourne automatiquement à l’état non signalé.AutoResetEvent remains signaled until a single waiting thread is released, and then automatically returns to the non-signaled state. Si aucun thread n’attend, l’état reste signalé indéfiniment.If no threads are waiting, the state remains signaled indefinitely.

Si un thread appelle WaitOne alors que AutoResetEvent est dans l’état signalé, le thread n’est pas bloqué.If a thread calls WaitOne while the AutoResetEvent is in the signaled state, the thread does not block. Le AutoResetEvent libère immédiatement le thread et revient à l’état non signalé.The AutoResetEvent releases the thread immediately and returns to the non-signaled state.

Important

Il n’y a aucune garantie que chaque appel à la Set méthode libérera un thread.There is no guarantee that every call to the Set method will release a thread. Si deux appels sont trop proches les uns des autres, afin que le deuxième appel se produise avant la libération d’un thread, un seul thread est libéré.If two calls are too close together, so that the second call occurs before a thread has been released, only one thread is released. C’est comme si le deuxième appel ne s’est pas produit.It's as if the second call did not happen. En outre, si Set est appelé alors qu’il n’y a aucun thread en attente et que le AutoResetEvent est déjà signalé, l’appel n’a aucun effet.Also, if Set is called when there are no threads waiting and the AutoResetEvent is already signaled, the call has no effect.

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 dans le false cas contraire.You can control the initial state of an AutoResetEvent by passing a Boolean value to the constructor: true if the initial state is signaled and false otherwise.

AutoResetEvent peut également être utilisé avec les static WaitAll WaitAny méthodes et.AutoResetEvent can also be used with the static WaitAll and WaitAny methods.

À partir de la version 2,0 de .NET Framework, AutoResetEvent dérive de la nouvelle EventWaitHandle classe.Beginning with the .NET Framework version 2.0, AutoResetEvent derives from the new EventWaitHandle class. Un AutoResetEvent est fonctionnellement équivalent à un EventWaitHandle créé avec EventResetMode.AutoReset .An AutoResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.AutoReset.

Notes

Contrairement AutoResetEvent à la classe, la EventWaitHandle classe fournit l’accès aux événements de synchronisation système nommés.Unlike the AutoResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

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é.Initializes a new instance of the AutoResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

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é.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Ce champ est constant.This field is constant.

(Hérité de WaitHandle)

Propriétés

Handle
Obsolète.

Obtient ou définit le handle du système d'exploitation natif.Gets or sets the native operating system handle.

(Hérité de WaitHandle)
SafeWaitHandle

Obtient ou définit le handle du système d'exploitation natif.Gets or sets the native operating system handle.

(Hérité de WaitHandle)

Méthodes

Close()

Libère toutes les ressources détenues par le WaitHandle actuel.Releases all resources held by the current WaitHandle.

(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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(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.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Hérité de WaitHandle)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(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.Gets an EventWaitHandleSecurity object that represents the access control security for the named system event represented by the current EventWaitHandle object.

(Hérité de EventWaitHandle)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

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.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
Reset()

Définit l'état de l'événement à "non signalé", ce qui entraîne le blocage des threads.Sets the state of the event to nonsignaled, which causes threads to block.

Reset()

Définit l'état de l'événement comme étant non signalé, entraînant le blocage des threads.Sets the state of the event to nonsignaled, causing threads to block.

(Hérité de EventWaitHandle)
Set()

Définit l'état de l'événement à "signalé", ce qui permet à un seul thread en attente de continuer à s'exécuter.Sets the state of the event to signaled, which allows at most one waiting thread to proceed.

Set()

Définit l'état de l'événement comme étant signalé, ce qui permet à un ou plusieurs threads en attente de continuer.Sets the state of the event to signaled, allowing one or more waiting threads to proceed.

(Hérité de EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)

Définit la sécurité de contrôle d’accès pour un événement système nommé.Sets the access control security for a named system event.

(Hérité de EventWaitHandle)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
WaitOne()

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.Blocks the current thread until the current WaitHandle receives a 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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Hérité de WaitHandle)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Libère toutes les ressources utilisées par WaitHandle.Releases all resources used by the WaitHandle.

(Hérité de WaitHandle)

Méthodes d’extension

GetAccessControl(EventWaitHandle)

Retourne les descripteurs de sécurité pour le handle spécifié.Returns the security descriptors for the specified handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Définit les descripteurs de sécurité pour le handle d’attente d’événement spécifié.Sets the security descriptors for the specified event wait handle.

GetSafeWaitHandle(WaitHandle)

Obtient le handle sécurisé pour un handle d’attente de système d’exploitation natif.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Définit un handle sécurisé pour un handle d’attente de système d’exploitation natif.Sets a safe handle for a native operating system wait handle.

S’applique à

Cohérence de thread

Cette classe est thread-safe.This class is thread safe.

Voir aussi