Jegyzet
Az oldalhoz való hozzáférés engedélyezést igényel. Próbálhatod be jelentkezni vagy könyvtárat váltani.
Az oldalhoz való hozzáférés engedélyezést igényel. Megpróbálhatod a könyvtár váltását.
System.Threading.CountdownEvent egy olyan szinkronizálási primitív, amely feloldja a várakozó szálak blokkolását, miután bizonyos számú jelzést kapott. CountdownEvent olyan forgatókönyvekre készült, amelyekben egyébként ManualResetEvent-t vagy ManualResetEventSlim-t kellene használnia, és manuálisan kellene csökkentenie egy változót, mielőtt jelzi az eseményt. Például egy fork/join párhuzamosítási forgatókönyvben létrehozhat egy CountdownEvent-t, amely 5 jelzéssel rendelkezik, majd öt munkaelemet indíthat el a szálkészleten, és minden munkaelem a befejezéskor meghívja a Signal-t. Minden Signal hívás 1-gyel csökkenti a jelszámot. A fő szálon a Wait hívás blokkolva marad, amíg a jel száma nulla nem lesz.
Megjegyzés
Azon kód esetében, amelynek nincs szüksége az örökölt .NET Framework szinkronizálási API-kkal való kommunikációra, érdemes megfontolni a System.Threading.Tasks.Task objektumokat vagy a Invoke metódust az elágaztatási párhuzamosság kifejezésének megkönnyítésére.
CountdownEvent a következő további funkciókkal rendelkezik:
A várakozási művelet lemondási jogkivonatok használatával megszakítható.
A jelszám a példány létrehozása után növelhető.
A példányok újra felhasználhatók, miután a Wait visszatért a Reset metódus meghívásával.
Az példányok egy WaitHandle-t biztosítanak más .NET szinkronizálási API-kkal való integrációhoz, mint például a WaitAll.
Alapszintű használat
Az alábbi példa bemutatja, hogyan használható a CountdownEvent a ThreadPool munkaelemekkel.
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 lemondással
Az alábbi példa bemutatja, hogyan lehet megszakítani a várakozási műveletet CountdownEvent egy törlési token használatával. Az alapminta a .NET-keretrendszer 4-ben bevezetett egységes lemondási modellt követi. További információ: Lemondás felügyelt szálakban.
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 {dataWithToken.Data.Num}");
return;
}
for (int i = 0; i < 10000; i++)
{
if (dataWithToken.Token.IsCancellationRequested)
{
Console.WriteLine($"Cancelling while executing {dataWithToken.Data.Num}");
return;
}
// Increase this value to slow down the program.
Thread.SpinWait(100000);
}
Console.WriteLine($"Processed {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
Vegye figyelembe, hogy a várakozási művelet nem szakítja meg az azt jelző szálakat. A rendszer általában egy logikai műveletre alkalmazza a lemondást, amely magában foglalhatja az eseményre való várakozást, valamint az összes olyan munkaelemet, amelyet a várakozás szinkronizál. Ebben a példában minden munkaelem megkapja ugyanazon megszakítási token egy példányát, hogy válaszolni tudjon a megszakítási kérelemre.
Lásd még
Működjön együtt velünk a GitHubon
Ennek a tartalomnak a forrása a GitHubon található, ahol problémákat és pull requesteket is létrehozhatsz és átnézhetsz. További információért lásd a közreműködői útmutatónkat.
