ManualResetEvent Classe

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Threading.dll

Source:

ManualResetEvent.cs

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 sealed class ManualResetEvent : System.Threading.EventWaitHandle

type ManualResetEvent = class
    inherit EventWaitHandle

Public NotInheritable Class ManualResetEvent
Inherits EventWaitHandle

Héritage

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Exemples

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

Le fait d’appuyer à nouveau sur la touche Entrée montre que les ManualResetEvent restes à l’état signalé jusqu’à ce que sa Reset méthode soit appelée : l’exemple démarre deux threads supplémentaires. Ces threads ne bloquent pas lorsqu’ils appellent la WaitOne méthode, mais s’exécutent à la fin.

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

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 des 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 mettre ManualResetEvent à l’état non signalé. Ce thread peut être considéré comme contrôlant le ManualResetEvent. Threads qui appellent le bloc ManualResetEvent.WaitOne , en attente du 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 signalé, ManualResetEvent il reste signalé jusqu’à ce qu’il soit réinitialisé manuellement en appelant la Reset() méthode. Autrement dit, les appels à WaitOne retourner immédiatement.

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

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

À compter de .NET Framework version 2.0, ManualResetEvent dérive de la classe EventWaitHandle. A ManualResetEvent est fonctionnellement équivalent à un EventWaitHandle créé avec EventResetMode.ManualReset.

Note

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

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

Constructeurs

Nom	Description
ManualResetEvent(Boolean)	Initialise une nouvelle instance de la ManualResetEvent 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