CountdownEvent Classe

  • Referência

Definição

Namespace:
System.Threading
Assembly:
System.Threading.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Representa um primitivo de sincronização que é sinalizado quando sua contagem atinge zero.

public ref class CountdownEvent : IDisposable
public class CountdownEvent : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class CountdownEvent : IDisposable
type CountdownEvent = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(false)>]
type CountdownEvent = class
    interface IDisposable
Public Class CountdownEvent
Implements IDisposable
Herança
Object
CountdownEvent
Atributos
ComVisibleAttribute
Implementações
IDisposable

Exemplos

O exemplo a seguir mostra como usar um CountdownEvent:

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    static async Task Main()
    {
        // Initialize a queue and a CountdownEvent
        ConcurrentQueue<int> queue = new ConcurrentQueue<int>(Enumerable.Range(0, 10000));
        CountdownEvent cde = new CountdownEvent(10000); // initial count = 10000

        // This is the logic for all queue consumers
        Action consumer = () =>
        {
            int local;
            // decrement CDE count once for each element consumed from queue
            while (queue.TryDequeue(out local)) cde.Signal();
        };

        // Now empty the queue with a couple of asynchronous tasks
        Task t1 = Task.Factory.StartNew(consumer);
        Task t2 = Task.Factory.StartNew(consumer);

        // And wait for queue to empty by waiting on cde
        cde.Wait(); // will return when cde count reaches 0

        Console.WriteLine("Done emptying queue.  InitialCount={0}, CurrentCount={1}, IsSet={2}",
            cde.InitialCount, cde.CurrentCount, cde.IsSet);

        // Proper form is to wait for the tasks to complete, even if you know that their work
        // is done already.
        await Task.WhenAll(t1, t2);

        // Resetting will cause the CountdownEvent to un-set, and resets InitialCount/CurrentCount
        // to the specified value
        cde.Reset(10);

        // AddCount will affect the CurrentCount, but not the InitialCount
        cde.AddCount(2);

        Console.WriteLine("After Reset(10), AddCount(2): InitialCount={0}, CurrentCount={1}, IsSet={2}",
            cde.InitialCount, cde.CurrentCount, cde.IsSet);

        // Now try waiting with cancellation
        CancellationTokenSource cts = new CancellationTokenSource();
        cts.Cancel(); // cancels the CancellationTokenSource
        try
        {
            cde.Wait(cts.Token);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("cde.Wait(preCanceledToken) threw OCE, as expected");
        }
        finally
        {
           cts.Dispose();
        }
        // It's good to release a CountdownEvent when you're done with it.
        cde.Dispose();
    }
}
// The example displays the following output:
//    Done emptying queue.  InitialCount=10000, CurrentCount=0, IsSet=True
//    After Reset(10), AddCount(2): InitialCount=10, CurrentCount=12, IsSet=False
//    cde.Wait(preCanceledToken) threw OCE, as expected

Imports System.Collections.Concurrent
Imports System.Linq
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Sub Main()
        ' Initialize a queue and a CountdownEvent
        Dim queue As New ConcurrentQueue(Of Integer)(Enumerable.Range(0, 10000))
        Dim cde As New CountdownEvent(10000)
        ' initial count = 10000
        ' This is the logic for all queue consumers
        Dim consumer As Action =
            Sub()
                Dim local As Integer
                ' decrement CDE count once for each element consumed from queue
                While queue.TryDequeue(local)
                    cde.Signal()
                End While
            End Sub

        ' Now empty the queue with a couple of asynchronous tasks
        Dim t1 As Task = Task.Factory.StartNew(consumer)
        Dim t2 As Task = Task.Factory.StartNew(consumer)

        ' And wait for queue to empty by waiting on cde
        cde.Wait()
        ' will return when cde count reaches 0
        Console.WriteLine("Done emptying queue. InitialCount={0}, CurrentCount={1}, IsSet={2}", cde.InitialCount, cde.CurrentCount, cde.IsSet)

        ' Proper form is to wait for the tasks to complete, even if you know that their work
        ' is done already.
        Task.WaitAll(t1, t2)

        ' Resetting will cause the CountdownEvent to un-set, and resets InitialCount/CurrentCount
        ' to the specified value
        cde.Reset(10)

        ' AddCount will affect the CurrentCount, but not the InitialCount
        cde.AddCount(2)

        Console.WriteLine("After Reset(10), AddCount(2): InitialCount={0}, CurrentCount={1}, IsSet={2}", cde.InitialCount, cde.CurrentCount, cde.IsSet)

        ' Now try waiting with cancellation
        Dim cts As New CancellationTokenSource()
        cts.Cancel()
        ' cancels the CancellationTokenSource
        Try
            cde.Wait(cts.Token)
        Catch generatedExceptionName As OperationCanceledException
            Console.WriteLine("cde.Wait(preCanceledToken) threw OCE, as expected")
        Finally
           cts.Dispose()
        End Try

        ' It's good to release a CountdownEvent when you're done with it.
        cde.Dispose()
    End Sub
End Module
' The example displays the following output:
'    Done emptying queue.  InitialCount=10000, CurrentCount=0, IsSet=True
'    After Reset(10), AddCount(2): InitialCount=10, CurrentCount=12, IsSet=False
'    cde.Wait(preCanceledToken) threw OCE, as expected

Construtores

CountdownEvent(Int32)

Inicializa uma nova instância da classe CountdownEvent com a contagem especificada.

Propriedades

CurrentCount

Obtém o número de sinais restantes necessárias para definir o evento.
InitialCount

Obtém os números de sinais inicialmente necessários para definir o evento.
IsSet

Indica se a contagem atual do objeto CountdownEvent chegou a zero.
WaitHandle

Obtém um WaitHandle que é usado para aguardar o evento a ser definido.

Métodos

AddCount()

Incrementa a contagem atual de CountdownEvent em um.
AddCount(Int32)

Incrementa a contagem atual de CountdownEvent em um valor especificado.
Dispose()

Libera todos os recursos usados pela instância atual da classe CountdownEvent.
Dispose(Boolean)

Libera os recursos não gerenciados usados pelo CountdownEvent 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()

Redefine o CurrentCount para o valor de InitialCount.
Reset(Int32)

Redefine a propriedade InitialCount com um valor especificado.
Signal()

Registra um sinal com o CountdownEvent, diminuindo o valor de CurrentCount.
Signal(Int32)

Registra vários sinais com o CountdownEvent, diminuindo o valor de CurrentCount pelo valor especificado.
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)
TryAddCount()

Tenta incrementar CurrentCount por um.
TryAddCount(Int32)

Tenta incrementar CurrentCount em um valor especificado.
Wait()

Bloqueia o thread atual até que o CountdownEvent seja definido.
Wait(CancellationToken)

Bloqueia o thread atual até que o CountdownEvent seja definido, enquanto observa um CancellationToken.
Wait(Int32)

Bloqueia o thread atual até que o CountdownEvent seja definido, usando um inteiro com sinal de 32 bits para medir o tempo limite.
Wait(Int32, CancellationToken)

Bloqueia o thread atual até que o CountdownEvent seja definido, usando um inteiro com sinal de 32 bits para medir o tempo limite, enquanto observa um CancellationToken.
Wait(TimeSpan)

Bloqueia o thread atual até que o CountdownEvent seja definido, usando um TimeSpan para medir o tempo limite.
Wait(TimeSpan, CancellationToken)

Bloqueia o thread atual até que o CountdownEvent seja definido, usando um TimeSpan para medir o tempo limite, enquanto observa um CancellationToken.

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos CountdownEvent 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 CountdownEvent tiverem sido concluídas e Reset(), que só devem ser usadas quando nenhum outro thread estiver acessando o evento.

Confira também