Procedure: SpinWait gebruiken om een tweefasenwachtbewerking te implementeren
In het volgende voorbeeld ziet u hoe u een System.Threading.SpinWait object gebruikt om een wachtbewerking in twee fasen te implementeren. In de eerste fase draait het synchronisatieobject, een Latch, draait voor een paar cycli terwijl wordt gecontroleerd of de vergrendeling beschikbaar is. In de tweede fase, als de vergrendeling beschikbaar komt, retourneert de Wait methode zonder de methode te gebruiken om de System.Threading.ManualResetEvent wacht uit te voeren. Anders Wait wordt de wachttijd uitgevoerd.
Opmerking
In dit voorbeeld ziet u een zeer eenvoudige implementatie van een Latch-synchronisatieprimitief. U kunt deze gegevensstructuur gebruiken wanneer de wachttijden naar verwachting zeer kort zijn. Dit voorbeeld is alleen bedoeld voor demonstratiedoeleinden. Als u vergrendelingsfunctionaliteit in uw programma nodig hebt, kunt u overwegen om te gebruiken System.Threading.ManualResetEventSlim.
#define LOGGING
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
class Latch
{
private object latchLock = new object();
// 0 = unset, 1 = set.
private int m_state = 0;
private volatile int totalKernelWaits = 0;
// Block threads waiting for ManualResetEvent.
private ManualResetEvent m_ev = new ManualResetEvent(false);
#if LOGGING
// For fast logging with minimal impact on latch behavior.
// Spin counts greater than 20 might be encountered depending on machine config.
private long[] spinCountLog = new long[20];
public void DisplayLog()
{
for (int i = 0; i < spinCountLog.Length; i++)
{
Console.WriteLine("Wait succeeded with spin count of {0} on {1:N0} attempts",
i, spinCountLog[i]);
}
Console.WriteLine("Wait used the kernel event on {0:N0} attempts.", totalKernelWaits);
Console.WriteLine("Logging complete");
}
#endif
public void Set()
{
lock(latchLock) {
m_state = 1;
m_ev.Set();
}
}
public void Wait()
{
Trace.WriteLine("Wait timeout infinite");
Wait(Timeout.Infinite);
}
public bool Wait(int timeout)
{
SpinWait spinner = new SpinWait();
Stopwatch watch;
while (m_state == 0)
{
// Lazily allocate and start stopwatch to track timeout.
watch = Stopwatch.StartNew();
// Spin only until the SpinWait is ready
// to initiate its own context switch.
if (!spinner.NextSpinWillYield)
{
spinner.SpinOnce();
}
// Rather than let SpinWait do a context switch now,
// we initiate the kernel Wait operation, because
// we plan on doing this anyway.
else
{
Interlocked.Increment(ref totalKernelWaits);
// Account for elapsed time.
long realTimeout = timeout - watch.ElapsedMilliseconds;
// Do the wait.
if (realTimeout <= 0 || !m_ev.WaitOne((int)realTimeout))
{
Trace.WriteLine("wait timed out.");
return false;
}
}
}
#if LOGGING
Interlocked.Increment(ref spinCountLog[spinner.Count]);
#endif
// Take the latch.
Interlocked.Exchange(ref m_state, 0);
return true;
}
}
class Example
{
static Latch latch = new Latch();
static int count = 2;
static CancellationTokenSource cts = new CancellationTokenSource();
static void TestMethod()
{
while (!cts.IsCancellationRequested)
{
// Obtain the latch.
if (latch.Wait(50))
{
// Do the work. Here we vary the workload a slight amount
// to help cause varying spin counts in latch.
double d = 0;
if (count % 2 != 0) {
d = Math.Sqrt(count);
}
Interlocked.Increment(ref count);
// Release the latch.
latch.Set();
}
}
}
static void Main()
{
// Demonstrate latch with a simple scenario: multiple
// threads updating a shared integer. Both operations
// are relatively fast, which enables the latch to
// demonstrate successful waits by spinning only.
latch.Set();
// UI thread. Press 'c' to cancel the loop.
Task.Factory.StartNew(() =>
{
Console.WriteLine("Press 'c' to cancel.");
if (Console.ReadKey(true).KeyChar == 'c') {
cts.Cancel();
}
});
Parallel.Invoke( () => TestMethod(),
() => TestMethod(),
() => TestMethod() );
#if LOGGING
latch.DisplayLog();
if (cts != null) cts.Dispose();
#endif
}
}
#Const LOGGING = 1
Imports System.Diagnostics
Imports System.Threading
Imports System.Threading.Tasks
Class Latch
Private latchLock As New Object()
' 0 = unset, 1 = set.
Private m_state As Integer = 0
Private totalKernelWaits As Integer = 0
' Block threads waiting for ManualResetEvent.
Private m_ev = New ManualResetEvent(False)
#If LOGGING Then
' For fast logging with minimal impact on latch behavior.
' Spin counts greater than 20 might be encountered depending on machine config.
Dim spinCountLog(19) As Long
Public Sub DisplayLog()
For i As Integer = 0 To spinCountLog.Length - 1
Console.WriteLine("Wait succeeded with spin count of {0} on {1:N0} attempts",
i, spinCountLog(i))
Next
Console.WriteLine("Wait used the kernel event on {0:N0} attempts.",
totalKernelWaits)
Console.WriteLine("Logging complete")
End Sub
#End If
Public Sub SetLatch()
SyncLock (latchLock)
m_state = 1
m_ev.Set()
End SyncLock
End Sub
Public Sub Wait()
Trace.WriteLine("Wait timeout infinite")
Wait(Timeout.Infinite)
End Sub
Public Function Wait(ByVal timeout As Integer) As Boolean
' Allocated on the stack.
Dim spinner = New SpinWait()
Dim watch As Stopwatch
While (m_state = 0)
' Lazily allocate and start stopwatch to track timeout.
watch = Stopwatch.StartNew()
' Spin only until the SpinWait is ready
' to initiate its own context switch.
If Not spinner.NextSpinWillYield Then
spinner.SpinOnce()
' Rather than let SpinWait do a context switch now,
' we initiate the kernel Wait operation, because
' we plan on doing this anyway.
Else
Interlocked.Increment(totalKernelWaits)
' Account for elapsed time.
Dim realTimeout As Long = timeout - watch.ElapsedMilliseconds
' Do the wait.
If realTimeout <= 0 OrElse Not m_ev.WaitOne(realTimeout) Then
Trace.WriteLine("wait timed out.")
Return False
End If
End If
End While
#If LOGGING Then
Interlocked.Increment(spinCountLog(spinner.Count))
#End If
' Take the latch.
Interlocked.Exchange(m_state, 0)
Return True
End Function
End Class
Class Program
Shared latch = New Latch()
Shared count As Integer = 2
Shared cts = New CancellationTokenSource()
Shared lockObj As New Object()
Shared Sub TestMethod()
While (Not cts.IsCancellationRequested)
' Obtain the latch.
If (latch.Wait(50)) Then
' Do the work. Here we vary the workload a slight amount
' to help cause varying spin counts in latch.
Dim d As Double = 0
If (count Mod 2 <> 0) Then
d = Math.Sqrt(count)
End If
SyncLock (lockObj)
If count = Int32.MaxValue Then count = 0
count += 1
End SyncLock
' Release the latch.
latch.SetLatch()
End If
End While
End Sub
Shared Sub Main()
' Demonstrate latch with a simple scenario:
' two threads updating a shared integer and
' accessing a shared StringBuilder. Both operations
' are relatively fast, which enables the latch to
' demonstrate successful waits by spinning only.
latch.SetLatch()
' UI thread. Press 'c' to cancel the loop.
Task.Factory.StartNew(Sub()
Console.WriteLine("Press 'c' to cancel.")
If (Console.ReadKey(True).KeyChar = "c"c) Then
cts.Cancel()
End If
End Sub)
Parallel.Invoke(
Sub() TestMethod(),
Sub() TestMethod(),
Sub() TestMethod()
)
#If LOGGING Then
latch.DisplayLog()
#End If
If cts IsNot Nothing Then cts.Dispose()
End Sub
End Class
De vergrendeling gebruikt het SpinWait object alleen om op zijn plaats te draaien totdat de volgende aanroep SpinOnce ervoor zorgt dat het SpinWait tijdssegment van de thread wordt gegenereerd. Op dat moment veroorzaakt de vergrendeling een eigen contextschakelaar door de ManualResetEvent rest van de time-outwaarde aan te roepen WaitOne en door te geven.
De uitvoer van logboekregistratie laat zien hoe vaak de latch de prestaties kon verhogen door de vergrendeling te verkrijgen zonder de ManualResetEvent.
Zie ook
Met ons samenwerken op GitHub
De bron voor deze inhoud vindt u op GitHub, waar u ook problemen en pull-aanvragen kunt maken en controleren. Bekijk onze gids voor inzenders voor meer informatie.
