CountdownEvent
System.Threading.CountdownEvent is een synchronisatieprimitief dat de wachtthreads deblokkert nadat het een bepaald aantal keren is gesignaleerd. CountdownEvent is ontworpen voor scenario's waarin u anders een ManualResetEvent of ManualResetEventSlim en handmatig een variabele moet gebruiken voordat u de gebeurtenis signaleert. In een fork-/joinscenario kunt u bijvoorbeeld gewoon een CountdownEvent teken maken met een signaalaantal van 5 en vervolgens vijf werkitems in de threadgroep starten en elk werkitem aanroepen Signal wanneer dit is voltooid. Elke aanroep om het aantal signaalen met 1 te Signal verlagen. Op de hoofdthread wordt de aanroep die moet Wait worden geblokkeerd totdat het aantal signaalen nul is.
Notitie
Voor code die niet hoeft te communiceren met verouderde .NET Framework-synchronisatie-API's, kunt u objecten of de Invoke methode gebruiken System.Threading.Tasks.Task voor een nog eenvoudigere benadering van het uitdrukken van parallelle uitvoering van fork-join.
CountdownEvent heeft deze aanvullende functies:
De wachtbewerking kan worden geannuleerd met behulp van annuleringstokens.
Het aantal signaal kan worden verhoogd nadat het exemplaar is gemaakt.
Exemplaren kunnen opnieuw worden gebruikt nadat Wait ze zijn geretourneerd door de methode aan te Reset roepen.
Exemplaren maken een WaitHandle beschikbaar voor integratie met andere .NET-synchronisatie-API's, zoals WaitAll.
Basisgebruik
In het volgende voorbeeld ziet u hoe u een CountdownEvent met ThreadPool werkitems gebruikt.
IEnumerable<Data> source = GetData();
using (CountdownEvent e = new CountdownEvent(1))
{
// fork work:
foreach (Data element in source)
{
// Dynamically increment signal count.
e.AddCount();
ThreadPool.QueueUserWorkItem(delegate(object state)
{
try
{
ProcessData(state);
}
finally
{
e.Signal();
}
},
element);
}
e.Signal();
// The first element could be run on this thread.
// Join with work.
e.Wait();
}
// .,.
Dim source As IEnumerable(Of Data) = GetData()
Dim e = New CountdownEvent(1)
' Fork work:
For Each element As Data In source
' Dynamically increment signal count.
e.AddCount()
ThreadPool.QueueUserWorkItem(Sub(state)
Try
ProcessData(state)
Finally
e.Signal()
End Try
End Sub,
element)
Next
' Decrement the signal count by the one we added
' in the constructor.
e.Signal()
' The first element could also be run on this thread.
' ProcessData(New Data(0))
' Join with work:
e.Wait()
Countdownevent met annulering
In het volgende voorbeeld ziet u hoe u de wachtbewerking CountdownEvent annuleert met behulp van een annuleringstoken. Het basispatroon volgt het model voor uniforme annulering, dat is geïntroduceerd in .NET Framework 4. Zie Annulering in Beheerde threads voor meer informatie.
class CancelableCountdownEvent
{
class Data
{
public int Num { get; set; }
public Data(int i) { Num = i; }
public Data() { }
}
class DataWithToken
{
public CancellationToken Token { get; set; }
public Data Data { get; private set; }
public DataWithToken(Data data, CancellationToken ct)
{
this.Data = data;
this.Token = ct;
}
}
static IEnumerable<Data> GetData()
{
return new List<Data>() { new Data(1), new Data(2), new Data(3), new Data(4), new Data(5) };
}
static void ProcessData(object obj)
{
DataWithToken dataWithToken = (DataWithToken)obj;
if (dataWithToken.Token.IsCancellationRequested)
{
Console.WriteLine("Canceled before starting {0}", dataWithToken.Data.Num);
return;
}
for (int i = 0; i < 10000; i++)
{
if (dataWithToken.Token.IsCancellationRequested)
{
Console.WriteLine("Cancelling while executing {0}", dataWithToken.Data.Num);
return;
}
// Increase this value to slow down the program.
Thread.SpinWait(100000);
}
Console.WriteLine("Processed {0}", dataWithToken.Data.Num);
}
static void Main(string[] args)
{
EventWithCancel();
Console.WriteLine("Press enter to exit.");
Console.ReadLine();
}
static void EventWithCancel()
{
IEnumerable<Data> source = GetData();
CancellationTokenSource cts = new CancellationTokenSource();
//Enable cancellation request from a simple UI thread.
Task.Factory.StartNew(() =>
{
if (Console.ReadKey().KeyChar == 'c')
cts.Cancel();
});
// Event must have a count of at least 1
CountdownEvent e = new CountdownEvent(1);
// fork work:
foreach (Data element in source)
{
DataWithToken item = new DataWithToken(element, cts.Token);
// Dynamically increment signal count.
e.AddCount();
ThreadPool.QueueUserWorkItem(delegate(object state)
{
ProcessData(state);
if (!cts.Token.IsCancellationRequested)
e.Signal();
},
item);
}
// Decrement the signal count by the one we added
// in the constructor.
e.Signal();
// The first element could be run on this thread.
// Join with work or catch cancellation.
try
{
e.Wait(cts.Token);
}
catch (OperationCanceledException oce)
{
if (oce.CancellationToken == cts.Token)
{
Console.WriteLine("User canceled.");
}
else
{
throw; //We don't know who canceled us!
}
}
finally {
e.Dispose();
cts.Dispose();
}
//...
} //end method
} //end class
Option Strict On
Option Explicit On
Imports System.Collections
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading
Imports System.Threading.Tasks
Module CancelEventWait
Class Data
Public Num As Integer
Public Sub New(ByVal i As Integer)
Num = i
End Sub
Public Sub New()
End Sub
End Class
Class DataWithToken
Public Token As CancellationToken
Public _data As Data
Public Sub New(ByVal d As Data, ByVal ct As CancellationToken)
Me._data = d
Me.Token = ct
End Sub
End Class
Class Program
Shared Function GetData() As IEnumerable(Of Data)
Dim nums = New List(Of Data)
For i As Integer = 1 To 5
nums.Add(New Data(i))
Next
Return nums
End Function
Shared Sub ProcessData(ByVal obj As Object)
Dim dataItem As DataWithToken = CType(obj, DataWithToken)
If dataItem.Token.IsCancellationRequested = True Then
Console.WriteLine("Canceled before starting {0}", dataItem._data.Num)
Exit Sub
End If
' Increase this value to slow down the program.
For i As Integer = 0 To 10000
If dataItem.Token.IsCancellationRequested = True Then
Console.WriteLine("Cancelling while executing {0}", dataItem._data.Num)
Exit Sub
End If
Thread.SpinWait(100000)
Next
Console.WriteLine("Processed {0}", dataItem._data.Num)
End Sub
Shared Sub Main()
DoEventWithCancel()
Console.WriteLine("Press the enter key to exit.")
Console.ReadLine()
End Sub
Shared Sub DoEventWithCancel()
Dim source As IEnumerable(Of Data) = GetData()
Dim cts As CancellationTokenSource = New CancellationTokenSource()
' Enable cancellation request from a simple UI thread.
Task.Factory.StartNew(Sub()
If Console.ReadKey().KeyChar = "c"c Then
cts.Cancel()
End If
End Sub)
' Must have a count of at least 1 or else it is signaled.
Dim e As CountdownEvent = New CountdownEvent(1)
For Each element As Data In source
Dim item As DataWithToken = New DataWithToken(element, cts.Token)
' Dynamically increment signal count.
e.AddCount()
ThreadPool.QueueUserWorkItem(Sub(state)
ProcessData(state)
If cts.Token.IsCancellationRequested = False Then
e.Signal()
End If
End Sub,
item)
Next
' Decrement the signal count by the one we added
' in the constructor.
e.Signal()
' The first element could be run on this thread.
' ProcessData(source(0))
' Join with work or catch cancellation exception
Try
e.Wait(cts.Token)
Catch ex As OperationCanceledException
If ex.CancellationToken = cts.Token Then
Console.WriteLine("User canceled.")
Else : Throw ' we don't know who canceled us.
End If
Finally
e.Dispose()
cts.Dispose()
End Try
End Sub
End Class
End Module
Houd er rekening mee dat de wachtbewerking de threads die deze signaleren niet annuleert. Normaal gesproken wordt annulering toegepast op een logische bewerking en kan het wachten op de gebeurtenis omvatten, evenals alle werkitems die door de wacht worden gesynchroniseerd. In dit voorbeeld wordt aan elk werkitem een kopie van hetzelfde annuleringstoken doorgegeven, zodat het kan reageren op de annuleringsaanvraag.
