ManualResetEvent Classe

Definizione

Spazio dei nomi:

System.Threading

Assembly:

System.Threading.dll

Origine:

ManualResetEvent.cs

Rappresenta un evento di sincronizzazione dei thread che, quando viene segnalato, deve essere reimpostato manualmente. La classe non può essere ereditata.

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

Ereditarietà

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Esempio

Nell'esempio seguente viene illustrato come ManualResetEvent funziona. L'esempio inizia con un ManualResetEvent oggetto nello stato non firmato, ovvero false passato al costruttore. Nell'esempio vengono creati tre thread, ognuno dei quali blocca l'oggetto ManualResetEvent chiamando il WaitOne relativo metodo. Quando l'utente preme il tasto INVIO , nell'esempio viene chiamato il Set metodo, che rilascia tutti e tre i thread. Contrasto con il comportamento della AutoResetEvent classe, che rilascia i thread uno alla volta, reimpostando automaticamente dopo ogni versione.

Premendo di nuovo il tasto INVIO viene illustrato che il valore rimane nello stato segnalato fino a quando non ManualResetEvent viene chiamato il Reset metodo: l'esempio avvia due altri thread. Questi thread non bloccano quando chiamano il WaitOne metodo, ma vengono eseguiti al completamento.

Premendo di nuovo il tasto INVIO , l'esempio chiama il Reset metodo e avvia un altro thread, che blocca quando chiama WaitOne. Premendo il tasto Invio una volta finale chiama Set per rilasciare l'ultimo thread e termina il programma.

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.

Commenti

Si usa ManualResetEvent, AutoResetEvente EventWaitHandle per l'interazione tra thread (o segnalazione thread). Per altre informazioni, vedere la sezione Interazione thread o segnalazionedell'articolo Panoramica delle primitive di sincronizzazione .

Quando un thread inizia un'attività che deve essere completata prima che altri thread proceda, chiama ManualResetEvent.Reset per inserire ManualResetEvent lo stato non segnalato. Questo thread può essere considerato come controllare l'oggetto ManualResetEvent. Thread che chiamano il blocco ManualResetEvent.WaitOne , in attesa del segnale. Quando il thread di controllo completa l'attività, chiama ManualResetEvent.Set per segnalare che i thread in attesa possono procedere. Tutti i thread in attesa vengono rilasciati.

Dopo aver segnalato, ManualResetEvent rimane segnalato fino a quando non viene reimpostato manualmente chiamando il Reset() metodo. Vale a dire, chiama a WaitOne restituire immediatamente.

È possibile controllare lo stato iniziale di un ManualResetEvent oggetto passando un valore booleano al costruttore: true se lo stato iniziale viene segnalato e false in caso contrario.

ManualResetEvent può essere usato anche con i staticWaitAll metodi e WaitAny .

A partire da .NET Framework versione 2.0, ManualResetEvent deriva dalla EventWaitHandle classe . Un ManualResetEvent oggetto equivale funzionalmente a un EventWaitHandle oggetto creato con EventResetMode.ManualReset.

Nota

A differenza della classe, la EventWaitHandle classe fornisce l'accesso ManualResetEvent agli eventi di sincronizzazione del sistema denominati.

A partire da .NET Framework versione 4.0, la System.Threading.ManualResetEventSlim classe è un'alternativa leggera a ManualResetEvent.

Costruttori

ManualResetEvent(Boolean)

Consente l'inizializzazione di una nuova istanza della classe ManualResetEvent con un valore Booleano che indica se lo stato iniziale deve essere impostato su segnalato.

Campi

WaitTimeout

Indica che si è verificato il timeout di un'operazione WaitAny(WaitHandle[], Int32, Boolean) prima della segnalazione di uno degli handle di attesa. Questo campo è costante. (Ereditato da WaitHandle)

Proprietà

Handle	Obsoleti. Ottiene o imposta l'handle nativo del sistema operativo. (Ereditato da WaitHandle)
SafeWaitHandle	Ottiene o imposta l'handle nativo del sistema operativo. (Ereditato da WaitHandle)

Metodi

Close()	Rilascia tutte le risorse contenute nell'oggetto WaitHandle corrente. (Ereditato da WaitHandle)
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate dall'istanza corrente della classe WaitHandle. (Ereditato da WaitHandle)
Dispose(Boolean)	Quando ne viene eseguito l'override in una classe derivata, libera le risorse non gestite usate da WaitHandle ed eventualmente di liberare le risorse gestite. (Ereditato da WaitHandle)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetAccessControl()	Ottiene un oggetto EventWaitHandleSecurity che rappresenta la sicurezza del controllo di accesso per l'evento di sistema denominato rappresentato dall'oggetto EventWaitHandle corrente. (Ereditato da EventWaitHandle)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
Reset()	Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread. (Ereditato da EventWaitHandle)
Set()	Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa di procedere. (Ereditato da EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)	Imposta la sicurezza del controllo di accesso per un evento di sistema denominato. (Ereditato da EventWaitHandle)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
WaitOne()	Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale. (Ereditato da WaitHandle)
WaitOne(Int32)	Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo. (Ereditato da WaitHandle)
WaitOne(Int32, Boolean)	Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale, usando un intero con segno a 32 bit per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa. (Ereditato da WaitHandle)
WaitOne(TimeSpan)	Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un valore TimeSpan per specificare l'intervallo di tempo. (Ereditato da WaitHandle)
WaitOne(TimeSpan, Boolean)	Blocca il thread corrente finché l'istanza corrente non riceve un segnale, usando un oggetto TimeSpan per specificare l'intervallo di tempo e indicando se uscire dal dominio di sincronizzazione prima dell'attesa. (Ereditato da WaitHandle)

Metodi di estensione

GetAccessControl(EventWaitHandle)	Restituisce i descrittori di sicurezza per l'oggetto handle specificato.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Imposta i descrittori di sicurezza per l'handle di attesa evento specificato.
GetSafeWaitHandle(WaitHandle)	Ottiene l'handle sicuro per un handle di attesa nativo del sistema operativo.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Imposta un handle sicuro per un handle di attesa nativo del sistema operativo.

Thread safety

Questa classe è thread safe.

Vedi anche

• WaitHandle
• Threading gestito
• Panoramica delle primitive di sincronizzazione