ManualResetEvent Classe

Definizione

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à

Object

WaitHandle

EventWaitHandle

ManualResetEvent

Ereditarietà

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Ereditarietà

Object

MarshalByRefObject

WaitHandle

ManualResetEvent

Attributi

ComVisibleAttribute

Esempio

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

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

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

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 usano ManualResetEvent, AutoResetEvente EventWaitHandle per l'interazione tra thread (o segnalazione di thread). Per altre informazioni, vedere la sezione Interazione tra thread o segnalazione dell'articolo Panoramica delle primitive di sincronizzazione .

Quando un thread avvia 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 continuare. Vengono rilasciati tutti i thread in attesa.

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

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

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

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

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

Thread safety

Questa classe è thread-safe.

Vedi anche

• WaitHandle
• di threading gestito
• Panoramica delle primitive di sincronizzazione