ManualResetEvent Classe

Définition

Représente un événement de synchronisation de threads qui, lorsqu’il est signalé, doit être réinitialisé manuellement. Cette classe ne peut pas être héritée.

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

Exemples

L’exemple suivant montre comment fonctionne ManualResetEvent. L’exemple commence par un ManualResetEvent dans l’état non signé (autrement dit, false est passé au constructeur). L’exemple crée trois threads, chacun de ces blocs sur le ManualResetEvent en appelant sa méthode WaitOne. Lorsque l’utilisateur appuie sur la touche Entrée, l’exemple appelle la méthode Set, qui libère les trois threads. Contrastez cela avec le comportement de la classe AutoResetEvent, qui libère les threads un par un, réinitialisant automatiquement après chaque mise en production.

En appuyant à nouveau sur la touche Entrée , le reste dans l’état signalé jusqu’à ce que sa méthode soit appelée : l’exemple démarre deux threads supplémentaires. Ces threads ne bloquent pas lorsqu’ils appellent la méthode WaitOne, mais s’exécutent à la fin.

En appuyant de nouveau sur la touche Entrée , l’exemple appelle la méthode et démarre un autre thread, ce qui bloque lorsqu’il appelle . Appuyez sur l'Entrer touche une dernière fois les appels Set pour libérer le dernier thread et le programme se termine.

using namespace System;
using namespace System::Threading;

ref class Example
{
private:
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    static ManualResetEvent^ mre = gcnew ManualResetEvent(false);

    static void ThreadProc()
    {
        String^ name = Thread::CurrentThread->Name;

        Console::WriteLine(name + " starts and calls mre->WaitOne()");

        mre->WaitOne();

        Console::WriteLine(name + " ends.");
    }

public:
    static void Demo()
    {
        Console::WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <=2 ; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                           "\nto release all the threads.\n");
        Console::ReadLine();

        mre->Set();

        Thread::Sleep(500);
        Console::WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                           "\ndo not block. Press Enter to show this.\n");
        Console::ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread^ t = gcnew Thread(gcnew ThreadStart(ThreadProc));
            t->Name = "Thread_" + i;
            t->Start();
        }

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                           "\nwhen they call WaitOne().\n");
        Console::ReadLine();

        mre->Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread^ t5 = gcnew Thread(gcnew ThreadStart(ThreadProc));
        t5->Name = "Thread_5";
        t5->Start();

        Thread::Sleep(500);
        Console::WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console::ReadLine();

        mre->Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console::ReadLine();
    }
};

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

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre->WaitOne()
Thread_1 starts and calls mre->WaitOne()
Thread_2 starts and calls mre->WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_1 ends.
Thread_0 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre->WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre->WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre->WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */
using System;
using System.Threading;

public class Example
{
    // mre is used to block and release threads manually. It is
    // created in the unsignaled state.
    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()
    {
        Console.WriteLine("\nStart 3 named threads that block on a ManualResetEvent:\n");

        for(int i = 0; i <= 2; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nWhen all three threads have started, press Enter to call Set()" +
                          "\nto release all the threads.\n");
        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500);
        Console.WriteLine("\nWhen a ManualResetEvent is signaled, threads that call WaitOne()" +
                          "\ndo not block. Press Enter to show this.\n");
        Console.ReadLine();

        for(int i = 3; i <= 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Reset(), so that threads once again block" +
                          "\nwhen they call WaitOne().\n");
        Console.ReadLine();

        mre.Reset();

        // Start a thread that waits on the ManualResetEvent.
        Thread t5 = new Thread(ThreadProc);
        t5.Name = "Thread_5";
        t5.Start();

        Thread.Sleep(500);
        Console.WriteLine("\nPress Enter to call Set() and conclude the demo.");
        Console.ReadLine();

        mre.Set();

        // If you run this example in Visual Studio, uncomment the following line:
        //Console.ReadLine();
    }

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

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");
    }
}

/* This example produces output similar to the following:

Start 3 named threads that block on a ManualResetEvent:

Thread_0 starts and calls mre.WaitOne()
Thread_1 starts and calls mre.WaitOne()
Thread_2 starts and calls mre.WaitOne()

When all three threads have started, press Enter to call Set()
to release all the threads.


Thread_2 ends.
Thread_0 ends.
Thread_1 ends.

When a ManualResetEvent is signaled, threads that call WaitOne()
do not block. Press Enter to show this.


Thread_3 starts and calls mre.WaitOne()
Thread_3 ends.
Thread_4 starts and calls mre.WaitOne()
Thread_4 ends.

Press Enter to call Reset(), so that threads once again block
when they call WaitOne().


Thread_5 starts and calls mre.WaitOne()

Press Enter to call Set() and conclude the demo.

Thread_5 ends.
 */
Imports System.Threading

Public Class Example

    ' mre is used to block and release threads manually. It is
    ' created in the unsignaled state.
    Private Shared mre As New ManualResetEvent(False)

    <MTAThreadAttribute> _
    Shared Sub Main()

        Console.WriteLine(vbLf & _
            "Start 3 named threads that block on a ManualResetEvent:" & vbLf)

        For i As Integer = 0 To 2
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When all three threads have started, press Enter to call Set()" & vbLf & _
            "to release all the threads." & vbLf)
        Console.ReadLine()

        mre.Set()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "When a ManualResetEvent is signaled, threads that call WaitOne()" & vbLf & _
            "do not block. Press Enter to show this." & vbLf)
        Console.ReadLine()

        For i As Integer = 3 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Name = "Thread_" & i
            t.Start()
        Next i

        Thread.Sleep(500)
        Console.WriteLine(vbLf & _
            "Press Enter to call Reset(), so that threads once again block" & vbLf & _
            "when they call WaitOne()." & vbLf)
        Console.ReadLine()

        mre.Reset()

        ' Start a thread that waits on the ManualResetEvent.
        Dim t5 As New Thread(AddressOf ThreadProc)
        t5.Name = "Thread_5"
        t5.Start()

        Thread.Sleep(500)
        Console.WriteLine(vbLf & "Press Enter to call Set() and conclude the demo.")
        Console.ReadLine()

        mre.Set()

        ' If you run this example in Visual Studio, uncomment the following line:
        'Console.ReadLine()

    End Sub


    Private Shared Sub ThreadProc()

        Dim name As String = Thread.CurrentThread.Name

        Console.WriteLine(name & " starts and calls mre.WaitOne()")

        mre.WaitOne()

        Console.WriteLine(name & " ends.")

    End Sub

End Class

' This example produces output similar to the following:
'
'Start 3 named threads that block on a ManualResetEvent:
'
'Thread_0 starts and calls mre.WaitOne()
'Thread_1 starts and calls mre.WaitOne()
'Thread_2 starts and calls mre.WaitOne()
'
'When all three threads have started, press Enter to call Set()
'to release all the threads.
'
'
'Thread_2 ends.
'Thread_0 ends.
'Thread_1 ends.
'
'When a ManualResetEvent is signaled, threads that call WaitOne()
'do not block. Press Enter to show this.
'
'
'Thread_3 starts and calls mre.WaitOne()
'Thread_3 ends.
'Thread_4 starts and calls mre.WaitOne()
'Thread_4 ends.
'
'Press Enter to call Reset(), so that threads once again block
'when they call WaitOne().
'
'
'Thread_5 starts and calls mre.WaitOne()
'
'Press Enter to call Set() and conclude the demo.
'
'Thread_5 ends.

Remarques

Vous utilisez ManualResetEvent, AutoResetEventet EventWaitHandle pour l’interaction de thread (ou la signalisation de thread). Pour plus d’informations, consultez la section Interaction entre threads ou signalisation de l’article Vue d’ensemble des primitives de synchronisation.

Lorsqu’un thread commence une activité qui doit se terminer avant que d’autres threads continuent, il appelle ManualResetEvent.Reset pour placer ManualResetEvent dans l’état non signalé. Ce thread peut être considéré comme le contrôle de la ManualResetEvent. Threads qui appellent ManualResetEvent.WaitOne bloc, en attendant le signal. Lorsque le thread de contrôle termine l’activité, il appelle ManualResetEvent.Set pour signaler que les threads en attente peuvent continuer. Tous les threads en attente sont libérés.

Une fois qu’elle a été signalée, ManualResetEvent reste signalée jusqu’à ce qu’elle soit réinitialisée manuellement en appelant la méthode Reset(). Autrement dit, les appels à WaitOne retourner immédiatement.

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

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

À compter de .NET Framework version 2.0, ManualResetEvent dérive de la classe EventWaitHandle. Une ManualResetEvent est fonctionnellement équivalente à une EventWaitHandle créée avec EventResetMode.ManualReset.

Note

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

À compter de .NET Framework version 4.0, la classe System.Threading.ManualResetEventSlim est une alternative légère à ManualResetEvent.

Constructeurs

ManualResetEvent(Boolean)

Initialise une nouvelle instance de la classe ManualResetEvent 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.
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.

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.

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)

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 le WaitHandle.

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

S’applique à

Cohérence de thread

Cette classe est thread safe.

Voir aussi