ManualResetEvent Classe

Definizione

Rappresenta un evento di sincronizzazione dei thread che, quando viene segnalato, deve essere reimpostato manualmente.Represents a thread synchronization event that, when signaled, must be reset manually. La classe non può essere ereditata.This class cannot be inherited.

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
Ereditarietà
ManualResetEvent
Ereditarietà
Ereditarietà
Attributi

Esempio

Nell'esempio seguente viene illustrato il ManualResetEvent funzionamento di.The following example demonstrates how ManualResetEvent works. L'esempio inizia con uno ManualResetEvent nello stato non segnalato, ovvero false viene passato al costruttore.The example starts with a ManualResetEvent in the unsignaled state (that is, false is passed to the constructor). Nell'esempio vengono creati tre thread, ciascuno dei quali si blocca su chiamando il ManualResetEvent relativo WaitOne metodo.The example creates three threads, each of which blocks on the ManualResetEvent by calling its WaitOne method. Quando l'utente preme il tasto invio , viene chiamato il Set metodo, che rilascia tutti e tre i thread.When the user presses the Enter key, the example calls the Set method, which releases all three threads. Questo comportamento si differenzia dal comportamento della AutoResetEvent classe, che rilascia i thread uno alla volta, reimpostando automaticamente dopo ogni rilascio.Contrast this with the behavior of the AutoResetEvent class, which releases threads one at a time, resetting automatically after each release.

Premendo di nuovo il tasto invio , viene dimostrato che ManualResetEvent rimane nello stato segnalato fino a quando non Reset viene chiamato il metodo: nell'esempio vengono avviati altri due thread.Pressing the Enter key again demonstrates that the ManualResetEvent remains in the signaled state until its Reset method is called: The example starts two more threads. Questi thread non vengono bloccati quando chiamano il WaitOne metodo, ma vengono invece eseguiti fino al completamento.These threads do not block when they call the WaitOne method, but instead run to completion.

Premendo di nuovo il tasto invio , l'esempio chiama il Reset metodo e avvia un altro thread, che blocca quando chiama WaitOne .Pressing the Enter key again causes the example to call the Reset method and to start one more thread, which blocks when it calls WaitOne. Premere il tasto invio una volta alla fine le chiamate Set per rilasciare l'ultimo thread e il programma termina.Pressing the Enter key one final time calls Set to release the last thread, and the program ends.

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 utilizzano ManualResetEvent , AutoResetEvent e EventWaitHandle per l'interazione del thread (o la segnalazione dei thread).You use ManualResetEvent, AutoResetEvent, and EventWaitHandle for thread interaction (or thread signaling). Per altre informazioni, vedere la sezione interazione dei thread o segnalazione dell'articolo Panoramica delle primitive di sincronizzazione .For more information, see the Thread interaction, or signaling section of the Overview of synchronization primitives article.

Quando un thread inizia un'attività che deve essere completata prima che altri thread continuino, chiama ManualResetEvent. Reset per inserire ManualResetEvent lo stato non segnalato.When a thread begins an activity that must complete before other threads proceed, it calls ManualResetEvent.Reset to put ManualResetEvent in the non-signaled state. Questo thread può essere considerato come il controllo di ManualResetEvent .This thread can be thought of as controlling the ManualResetEvent. Thread che chiamano il blocco ManualResetEvent. WaitOne , in attesa del segnale.Threads that call ManualResetEvent.WaitOne block, awaiting the signal. Quando il thread di controllo completa l'attività, chiama ManualResetEvent. set per segnalare che i thread in attesa possono continuare.When the controlling thread completes the activity, it calls ManualResetEvent.Set to signal that the waiting threads can proceed. Vengono rilasciati tutti i thread in attesa.All waiting threads are released.

Una volta segnalato, ManualResetEvent rimane segnalato fino a quando non viene reimpostato manualmente chiamando il Reset() metodo.Once it has been signaled, ManualResetEvent remains signaled until it is manually reset by calling the Reset() method. Ovvero, le chiamate a WaitOne restituiscono immediatamente.That is, calls to WaitOne return immediately.

È possibile controllare lo stato iniziale di un ManualResetEvent passando un valore booleano al costruttore: true se lo stato iniziale viene segnalato e false in caso contrario.You can control the initial state of a ManualResetEvent by passing a Boolean value to the constructor: true if the initial state is signaled, and false otherwise.

ManualResetEvent può essere usato anche con i static WaitAll WaitAny metodi e.ManualResetEvent can also be used with the static WaitAll and WaitAny methods.

A partire da .NET Framework versione 2,0, ManualResetEvent deriva dalla EventWaitHandle classe.Beginning with the .NET Framework version 2.0, ManualResetEvent derives from the EventWaitHandle class. Un oggetto ManualResetEvent è funzionalmente equivalente a un oggetto EventWaitHandle creato con EventResetMode.ManualReset .A ManualResetEvent is functionally equivalent to an EventWaitHandle created with EventResetMode.ManualReset.

Nota

A differenza della ManualResetEvent classe, la EventWaitHandle classe fornisce l'accesso agli eventi di sincronizzazione di sistema denominati.Unlike the ManualResetEvent class, the EventWaitHandle class provides access to named system synchronization events.

A partire da .NET Framework versione 4,0, la System.Threading.ManualResetEventSlim classe è un'alternativa semplice a ManualResetEvent .Beginning with the .NET Framework version 4.0, the System.Threading.ManualResetEventSlim class is a lightweight alternative to 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.Initializes a new instance of the ManualResetEvent class with a Boolean value indicating whether to set the initial state to signaled.

Campi

WaitTimeout

Indica che si è verificato il timeout di un'operazione WaitAny(WaitHandle[], Int32, Boolean) prima della segnalazione di uno degli handle di attesa.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Questo campo è costante.This field is constant.

(Ereditato da WaitHandle)

Proprietà

Handle
Obsoleta.

Ottiene o imposta l'handle nativo del sistema operativo.Gets or sets the native operating system handle.

(Ereditato da WaitHandle)
SafeWaitHandle

Ottiene o imposta l'handle nativo del sistema operativo.Gets or sets the native operating system handle.

(Ereditato da WaitHandle)

Metodi

Close()

Rilascia tutte le risorse contenute nell'oggetto WaitHandle corrente.Releases all resources held by the current WaitHandle.

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

(Ereditato da MarshalByRefObject)
Dispose()

Rilascia tutte le risorse usate dall'istanza corrente della classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

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

(Ereditato da WaitHandle)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

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

(Ereditato da EventWaitHandle)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Ereditato da MarshalByRefObject)
Reset()

Imposta lo stato dell'evento su non segnalato, provocando il blocco dei thread.Sets the state of the event to nonsignaled, which causes threads to block.

Reset()

Imposta lo stato dell'evento come non segnalato, provocando il blocco dei thread.Sets the state of the event to nonsignaled, causing threads to block.

(Ereditato da EventWaitHandle)
Set()

Imposta lo stato dell'evento su segnalato, per consentire a uno o più thread in attesa di procedere.Sets the state of the event to signaled, which allows one or more waiting threads to proceed.

Set()

Imposta lo stato dell'evento su segnalato, per consentire a uno più thread in attesa di continuare.Sets the state of the event to signaled, allowing one or more waiting threads to proceed.

(Ereditato da EventWaitHandle)
SetAccessControl(EventWaitHandleSecurity)

Imposta la sicurezza del controllo di accesso per un evento di sistema denominato.Sets the access control security for a named system event.

(Ereditato da EventWaitHandle)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
WaitOne()

Blocca il thread corrente finché l'oggetto WaitHandle corrente non riceve un segnale.Blocks the current thread until the current WaitHandle receives a signal.

(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

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

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

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

(Ereditato da WaitHandle)

Implementazioni dell'interfaccia esplicita

IDisposable.Dispose()

Questa API supporta l'infrastruttura del prodotto e non è previsto che venga usata direttamente dal codice.

Rilascia tutte le risorse usate da WaitHandle.Releases all resources used by the WaitHandle.

(Ereditato da WaitHandle)

Metodi di estensione

GetAccessControl(EventWaitHandle)

Restituisce i descrittori di sicurezza per l'oggetto handle specificato.Returns the security descriptors for the specified handle.

SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)

Imposta i descrittori di sicurezza per l'handle di attesa evento specificato.Sets the security descriptors for the specified event wait handle.

GetSafeWaitHandle(WaitHandle)

Ottiene l'handle sicuro per un handle di attesa nativo del sistema operativo.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Imposta un handle sicuro per un handle di attesa nativo del sistema operativo.Sets a safe handle for a native operating system wait handle.

Si applica a

Thread safety

Questa classe è thread-safe.This class is thread safe.

Vedi anche