ManualResetEventSlim Classe

Referência

Definição

Namespace:: System.Threading

Assembly:: System.Threading.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa um evento de sincronização de thread que, quando sinalizado, deve ser redefinido manualmente. Esta classe é uma alternativa leve para ManualResetEvent.

public ref class ManualResetEventSlim : IDisposable

public class ManualResetEventSlim : IDisposable

[System.Runtime.InteropServices.ComVisible(false)]
public class ManualResetEventSlim : IDisposable

type ManualResetEventSlim = class
    interface IDisposable

[<System.Runtime.InteropServices.ComVisible(false)>]
type ManualResetEventSlim = class
    interface IDisposable

Public Class ManualResetEventSlim
Implements IDisposable

Herança: Object
ManualResetEventSlim

Atributos: ComVisibleAttribute

Implementações: IDisposable

Exemplos

O exemplo a seguir mostra como usar um ManualResetEventSlim.

using System;
using System.Threading;
using System.Threading.Tasks;
class MRESDemo
{

    static void Main()
    {
        MRES_SetWaitReset();
        MRES_SpinCountWaitHandle();
    }
    // Demonstrates:
    //      ManualResetEventSlim construction
    //      ManualResetEventSlim.Wait()
    //      ManualResetEventSlim.Set()
    //      ManualResetEventSlim.Reset()
    //      ManualResetEventSlim.IsSet
    static void MRES_SetWaitReset()
    {
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres3 = new ManualResetEventSlim(true);  // initialize as signaled

        // Start an asynchronous Task that manipulates mres3 and mres2
        var observer = Task.Factory.StartNew(() =>
        {
            mres1.Wait();
            Console.WriteLine("observer sees signaled mres1!");
            Console.WriteLine("observer resetting mres3...");
            mres3.Reset(); // should switch to unsignaled
            Console.WriteLine("observer signalling mres2");
            mres2.Set();
        });

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet);
        Console.WriteLine("main thread signalling mres1");
        mres1.Set(); // This will "kick off" the observer Task
        mres2.Wait(); // This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!");
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet);

        // It's good form to Dispose() a ManualResetEventSlim when you're done with it
        observer.Wait(); // make sure that this has fully completed
        mres1.Dispose();
        mres2.Dispose();
        mres3.Dispose();
    }

    // Demonstrates:
    //      ManualResetEventSlim construction w/ SpinCount
    //      ManualResetEventSlim.WaitHandle
    static void MRES_SpinCountWaitHandle()
    {
        // Construct a ManualResetEventSlim with a SpinCount of 1000
        // Higher spincount => longer time the MRES will spin-wait before taking lock
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false, 1000);
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false, 1000);

        Task bgTask = Task.Factory.StartNew(() =>
        {
            // Just wait a little
            Thread.Sleep(100);

            // Now signal both MRESes
            Console.WriteLine("Task signalling both MRESes");
            mres1.Set();
            mres2.Set();
        });

        // A common use of MRES.WaitHandle is to use MRES as a participant in 
        // WaitHandle.WaitAll/WaitAny.  Note that accessing MRES.WaitHandle will
        // result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(new WaitHandle[] { mres1.WaitHandle, mres2.WaitHandle });
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.");

        // Clean up
        bgTask.Wait();
        mres1.Dispose();
        mres2.Dispose();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Module MRESDemo

    Sub Main()

    End Sub
    ' Demonstrates:
    ' ManualResetEventSlim construction
    ' ManualResetEventSlim.Wait()
    ' ManualResetEventSlim.Set()
    ' ManualResetEventSlim.Reset()
    ' ManualResetEventSlim.IsSet
    Private Sub MRES_SetWaitReset()
        ' initialize as unsignaled
        Dim mres1 As New ManualResetEventSlim(False)
        ' initialize as unsignaled
        Dim mres2 As New ManualResetEventSlim(False)
        ' initialize as signaled
        Dim mres3 As New ManualResetEventSlim(True)

        ' Start an asynchronous Task that manipulates mres3 and mres2
        Dim observer = Task.Factory.StartNew(
            Sub()
                mres1.Wait()
                Console.WriteLine("observer sees signaled mres1!")
                Console.WriteLine("observer resetting mres3...")
                mres3.Reset()
                ' should switch to unsignaled
                Console.WriteLine("observer signalling mres2")
                mres2.[Set]()
            End Sub)

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet)
        Console.WriteLine("main thread signalling mres1")
        mres1.[Set]()
        ' This will "kick off" the observer Task
        mres2.Wait()
        ' This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!")
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet)

        ' make sure that observer has fully completed
        observer.Wait()
        ' It's good form to Dispose() a ManualResetEventSlim when you're done with it
        mres1.Dispose()
        mres2.Dispose()
        mres3.Dispose()
    End Sub

    ' Demonstrates:
    ' ManualResetEventSlim construction w/ SpinCount
    ' ManualResetEventSlim.WaitHandle
    Private Sub MRES_SpinCountWaitHandle()
        ' Construct a ManualResetEventSlim with a SpinCount of 1000
        ' Higher spincount => longer time the MRES will spin-wait before taking lock
        Dim mres1 As New ManualResetEventSlim(False, 1000)
        Dim mres2 As New ManualResetEventSlim(False, 1000)

        Dim bgTask As Task = Task.Factory.StartNew(
            Sub()
                ' Just wait a little
                Thread.Sleep(100)

                ' Now signal both MRESes
                Console.WriteLine("Task signalling both MRESes")
                mres1.[Set]()
                mres2.[Set]()
            End Sub)

        ' A common use of MRES.WaitHandle is to use MRES as a participant in 
        ' WaitHandle.WaitAll/WaitAny. Note that accessing MRES.WaitHandle will
        ' result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(New WaitHandle() {mres1.WaitHandle, mres2.WaitHandle})
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.")

        ' Wait for bgTask to complete and clean up
        bgTask.Wait()
        mres1.Dispose()
        mres2.Dispose()
    End Sub
End Module

Comentários

Você pode usar essa classe para um melhor desempenho do que ManualResetEvent quando os tempos de espera devem ser muito curtos e quando o evento não cruza um limite de processo. O ManualResetEventSlim usa a rotação ocupada por um curto período enquanto aguarda a sinalização do evento. Quando os tempos de espera são curtos, a rotação pode ser muito menos dispendiosa do que a espera usando os identificadores de espera. No entanto, se o evento não for sinalizado dentro de um determinado período de tempo, ManualResetEventSlim recorre a uma espera de identificador de evento regular.

Observação

No .NET Core e no .NET 5+, a duração de espera de rotação padrão é curta: na ordem de 10s de microssegundos, dependendo da plataforma e do processador. Se você espera que os tempos de espera sejam muito mais longos do que isso, você ainda poderá usar essa classe em vez de ManualResetEvent (talvez configurado com menos ou nenhum spin-waiting). No entanto, o benefício de desempenho provavelmente seria apenas marginal.

Construtores

ManualResetEventSlim()	Inicializa uma nova instância da classe ManualResetEventSlim com um estado inicial de não sinalizado.
ManualResetEventSlim(Boolean)	Inicializa uma nova instância da classe ManualResetEventSlim com um valor booliano que indica se é necessário definir o estado inicial como sinalizado.
ManualResetEventSlim(Boolean, Int32)	Inicializa uma nova instância da classe ManualResetEventSlim com um valor booliano que indica se é necessário definir o estado inicial como sinalizado e uma contagem de rotação especificada.

Propriedades

IsSet	Descobre se o evento está definido.
SpinCount	Obtém o número de esperas de rotação que ocorrerão antes de retornar para uma operação de espera com base em kernel.
WaitHandle	Obtém o objeto WaitHandle subjacente para este ManualResetEventSlim.

Métodos

Dispose()	Libera todos os recursos usados pela instância atual da classe ManualResetEventSlim.
Dispose(Boolean)	Libera os recursos não gerenciados usados pelo ManualResetEventSlim e opcionalmente libera os recursos gerenciados.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
Reset()	Define o estado do evento como não sinalizado, o que causa o bloqueio dos threads.
Set()	Define o estado do evento a ser sinalizado, que permite que um ou mais threads aguardem a continuação do evento.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
Wait()	Bloqueia o thread atual até que o ManualResetEventSlim seja definido.
Wait(CancellationToken)	Bloqueia o thread atual até que o ManualResetEventSlim atual receba um sinal, enquanto observa um CancellationToken.
Wait(Int32)	Bloqueia o thread atual até que o ManualResetEventSlim atual seja definido, usando um inteiro com sinal de 32 bits para medir o intervalo de tempo.
Wait(Int32, CancellationToken)	Bloqueia o thread atual até que o ManualResetEventSlim atual seja definido, usando um inteiro com sinal de 32 bits para medir o intervalo de tempo, enquanto observa um CancellationToken.
Wait(TimeSpan)	Bloqueia o thread atual até que o ManualResetEventSlim atual seja definido, usando um TimeSpan para medir o intervalo de tempo.
Wait(TimeSpan, CancellationToken)	Bloqueia o thread atual até que o ManualResetEventSlim atual seja definido, usando um TimeSpan para medir o intervalo de tempo, enquanto observa um CancellationToken.

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos ManualResetEventSlim são thread-safe e podem ser usados simultaneamente de vários threads, com exceção de Dispose, que só deve ser usado quando todas as outras operações no ManualResetEventSlim ter concluído e Redefinir, que só devem ser usadas quando nenhum outro thread estiver acessando o evento.

Confira também

Visão geral dos primitivos de sincronização

Compartilhar via