SpinWait
System.Threading.SpinWait è un tipo di sincronizzazione leggera che è possibile usare in scenari di basso livello per evitare i cambi di contesto dispendiosi e le transizioni del kernel necessarie per gli eventi del kernel. Nei computer multicore, quando non si prevede che una risorsa venga bloccata per lunghi periodi di tempo, per un thread in attesa potrebbe essere più efficiente ruotare in modalità utente per alcune decine o centinaia di cicli e quindi ritentare di acquisire la risorsa. Se la risorsa è disponibile dopo la rotazione, vengono risparmiate diverse migliaia di cicli. Se la risorsa continua a non essere disponibile, sono stati usati solo alcuni cicli ed è possibile attivare un'attesa basata sul kernel. Questa combinazione di rotazione-attesa è talvolta detta un operazione di attesa a due fasi.
SpinWait è progettato per essere usato in combinazione con i tipi di .NET che eseguono il wrapping di eventi del kernel, ad esempio ManualResetEvent. SpinWait può essere usato anche da solo per la funzionalità di rotazione di base in un unico programma.
SpinWait è molto più di un ciclo vuoto. Viene implementato con particolare attenzione per offrire un comportamento di rotazione corretto per usi generali; avvia cambi di contesto in caso di rotazione per una durata sufficiente (approssimativamente l'intervallo di tempo necessario per una transizione del kernel). Ad esempio, nei computer a core singolo, SpinWait restituisce subito l'intervallo di tempo del thread perché la rotazione impedisce l'avanzamento per tutti i thread. SpinWait restituisce il controllo anche in computer multicore per impedire al thread in attesa di bloccare i thread con priorità superiore o la funzionalità Garbage Collector. Pertanto, se si usa SpinWait in un'operazione di attesa a due fasi, è consigliabile richiamare l'attesa del kernel prima che SpinWait avvii un cambio di contesto. SpinWait fornisce la proprietà NextSpinWillYield, che è possibile controllare prima di ogni chiamata a SpinOnce. Quando la proprietà restituisce true, avviare l'operazione di attesa. Per un esempio, vedere Procedura: Usare SpinWait per implementare un'operazione di attesa a due fasi.
Se non si esegue un'operazione di attesa a due fasi, ma la rotazione continua finché una condizione è vera, è possibile abilitare SpinWait per eseguire i relativi cambi di contesto in modo che sia un elemento positivo nell'ambiente del sistema operativo Windows. L'esempio di base seguente illustra un SpinWait in uno stack senza blocco. Se è necessario uno stack thread-safe e ad alte prestazioni, è consigliabile usare System.Collections.Concurrent.ConcurrentStack<T>.
public class LockFreeStack<T>
{
private volatile Node m_head;
private class Node { public Node Next; public T Value; }
public void Push(T item)
{
var spin = new SpinWait();
Node node = new Node { Value = item }, head;
while (true)
{
head = m_head;
node.Next = head;
if (Interlocked.CompareExchange(ref m_head, node, head) == head) break;
spin.SpinOnce();
}
}
public bool TryPop(out T result)
{
result = default(T);
var spin = new SpinWait();
Node head;
while (true)
{
head = m_head;
if (head == null) return false;
if (Interlocked.CompareExchange(ref m_head, head.Next, head) == head)
{
result = head.Value;
return true;
}
spin.SpinOnce();
}
}
}
Imports System.Threading
Module SpinWaitDemo
Public Class LockFreeStack(Of T)
Private m_head As Node
Private Class Node
Public [Next] As Node
Public Value As T
End Class
Public Sub Push(ByVal item As T)
Dim spin As New SpinWait()
Dim head As Node, node As New Node With {.Value = item}
While True
Thread.MemoryBarrier()
head = m_head
node.Next = head
If Interlocked.CompareExchange(m_head, node, head) Is head Then Exit While
spin.SpinOnce()
End While
End Sub
Public Function TryPop(ByRef result As T) As Boolean
result = CType(Nothing, T)
Dim spin As New SpinWait()
Dim head As Node
While True
Thread.MemoryBarrier()
head = m_head
If head Is Nothing Then Return False
If Interlocked.CompareExchange(m_head, head.Next, head) Is head Then
result = head.Value
Return True
End If
spin.SpinOnce()
End While
End Function
End Class
End Module
