ManualResetEvent Classe

Definição

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

Herança

Object

WaitHandle

EventWaitHandle

ManualResetEvent

Herança

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

ManualResetEvent

Herança

Object

MarshalByRefObject

WaitHandle

ManualResetEvent

Atributos

ComVisibleAttribute

Exemplos

O exemplo seguinte demonstra como ManualResetEvent funciona. O exemplo começa com a ManualResetEvent no estado não sinalizado (isto é, false é passado ao construtor). O exemplo cria três threads, cada um dos quais bloqueia no ManualResetEvent ao chamar o seu WaitOne método. Quando o utilizador pressiona a tecla Enter , o exemplo chama o Set método, que liberta as três threads. Contraste isto com o comportamento da AutoResetEvent classe, que liberta os threads um de cada vez, reiniciando-se automaticamente após cada lançamento.

Pressionar novamente a tecla Enter demonstra que o ManualResetEvent Up permanece no estado sinalizado até que o seu Reset método seja chamado: O exemplo inicia mais dois threads. Estas threads não bloqueiam quando chamam o WaitOne método, mas executam até à conclusão.

Ao pressionar novamente a tecla Enter , o exemplo chama o Reset método e inicia mais uma thread, que bloqueia quando chama WaitOne. Pressionar a tecla Enter uma última vez chama Set a libertação do último fio, e o programa 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.

Observações

Usas ManualResetEvent, AutoResetEvent, e EventWaitHandle para interação de threads (ou sinalização de thread). Para mais informações, consulte a secção Interação de Fios, ou sinalização do artigo Visão Geral das primitivas de sincronização .

Quando uma thread inicia uma atividade que deve ser concluída antes que outras threads prossigam, chama ManualResetEvent.Reset para colocar ManualResetEvent no estado não sinalizado. Este fio pode ser visto como controlando o ManualResetEvent. Threads que chamam o bloco ManualResetEvent.WaitOne , à espera do sinal. Quando o thread controlador conclui a atividade, chama o ManualResetEvent.Set para sinalizar que os threads em espera podem avançar. Todos os tópicos em espera são divulgados.

Uma vez sinalizado, ManualResetEvent permanece sinalizado até ser reiniciado manualmente ao chamar o Reset() método. Ou seja, chamadas para WaitOne regressar imediatamente.

Pode controlar o estado inicial de a ManualResetEvent passando um valor booleano ao construtor: true se o estado inicial for sinalizado, e false caso contrário.

ManualResetEventpode também ser usado com os staticWaitAll métodos e.WaitAny

A partir da versão 2.0 do .NET Framework, ManualResetEvent deriva da classe EventWaitHandle. A ManualResetEvent é funcionalmente equivalente a um EventWaitHandle criado com EventResetMode.ManualReset.

A partir da versão 4.0 do .NET Framework, a classe System.Threading.ManualResetEventSlim é uma alternativa leve ao ManualResetEvent.

Segurança de Thread

Esta aula é segura para fios.

Ver também

• WaitHandle
• de threading gerenciado
• Visão geral das primitivas de sincronização