SpinWaitSpinWait

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.System.Threading.SpinWait is a lightweight synchronization type that you can use in low-level scenarios to avoid the expensive context switches and kernel transitions that are required for kernel events. 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.On multicore computers, when a resource is not expected to be held for long periods of time, it can be more efficient for a waiting thread to spin in user mode for a few dozen or a few hundred cycles, and then retry to acquire the resource. Se la risorsa è disponibile dopo la rotazione, vengono risparmiate diverse migliaia di cicli.If the resource is available after spinning, then you have saved several thousand cycles. Se la risorsa continua a non essere disponibile, sono stati usati solo alcuni cicli ed è possibile attivare un'attesa basata sul kernel.If the resource is still not available, then you have spent only a few cycles and can still enter a kernel-based wait. Questa combinazione di rotazione-attesa è talvolta detta un operazione di attesa a due fasi.This spinning-then-waiting combination is sometimes referred to as a two-phase wait operation.

SpinWait è progettato per essere usato in combinazione con i tipi di .NET Framework che eseguono il wrapping di eventi del kernel, ad esempio ManualResetEvent.SpinWait is designed to be used in conjunction with the .NET Framework types that wrap kernel events such as ManualResetEvent. SpinWait può essere usato anche da solo per la funzionalità di rotazione di base in un unico programma.SpinWait can also be used by itself for basic spinning functionality in just one program.

SpinWait è molto più di un ciclo vuoto.SpinWait is more than just an empty loop. 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).It is carefully implemented to provide correct spinning behavior for the general case, and will itself initiate context switches if it spins long enough (roughly the length of time required for a kernel transition). 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.For example, on single-core computers, SpinWait yields the time slice of the thread immediately because spinning blocks forward progress on all threads. 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.SpinWait also yields even on multi-core machines to prevent the waiting thread from blocking higher-priority threads or the 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.Therefore, if you are using a SpinWait in a two-phase wait operation, we recommend that you invoke the kernel wait before the SpinWait itself initiates a context switch. SpinWait fornisce la proprietà NextSpinWillYield, che è possibile controllare prima di ogni chiamata a SpinOnce.SpinWait provides the NextSpinWillYield property, which you can check before every call to SpinOnce. Quando la proprietà restituisce true, avviare l'operazione di attesa.When the property returns true, initiate your own Wait operation. Per un esempio, vedere Procedura: Usare SpinWait per implementare un'operazione di attesa a due fasi.For an example, see How to: Use SpinWait to Implement a Two-Phase Wait Operation.

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.If you are not performing a two-phase wait operation but are just spinning until some condition is true, you can enable SpinWait to perform its context switches so that it is a good citizen in the Windows operating system environment. L'esempio di base seguente illustra un SpinWait in uno stack senza blocco.The following basic example shows a SpinWait in a lock-free stack. Se è necessario uno stack thread-safe e ad alte prestazioni, è consigliabile usare System.Collections.Concurrent.ConcurrentStack<T>.If you require a high-performance, thread-safe stack, consider using 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

Vedere ancheSee Also

SpinWait
Oggetti e funzionalità del threadingThreading Objects and Features