Sdílet prostřednictvím

SpinWait

System.Threading.SpinWait je jednoduchý typ synchronizace, který můžete použít ve scénářích nízké úrovně, abyste se vyhnuli drahým přepínačům kontextu a přechodům jádra, které jsou vyžadovány pro události jádra. Na více jádrových počítačích, pokud se neočekává, že bude prostředek držen po dlouhou dobu, může být efektivnější pro čekající vlákno, aby se otáčelo v uživatelském režimu po dobu několika desítek nebo stovek cyklů, a poté se pokusilo získat prostředek znovu. Pokud je zdroj po otočení k dispozici, ušetřili jste několik tisíc cyklů. Pokud prostředek stále není dostupný, strávili jste pouze několik cyklů a stále můžete zadat čekání založené na jádru. Tato kombinace rotování a čekání se někdy označuje jako dvoufázová operace čekání.

SpinWait je navržen pro použití ve spojení s typy .NET, které zabalí události jádra, jako ManualResetEvent. SpinWait lze také použít sám pro základní rotující funkce pouze v jednom programu.

SpinWait je více než jen prázdná smyčka. Je pečlivě implementováno, aby poskytovalo správné rotující chování pro obecný případ, a sám se spustí kontextové přepínače, pokud se roztáčí dostatečně dlouho (zhruba doba potřebná pro přechod jádra). Například na počítačích s jedním jádrem SpinWait automaticky získá časový úsek vlákna, protože otáčení blokuje pokrok všech vláken. SpinWait také na počítačích s více jádry umožní čekacímu vláknu ustoupit, aby zabránilo blokování vláken s vyšší prioritou nebo rušení garbage kolektoru. Proto, pokud používáte SpinWait v dvoufázové operaci čekání, doporučujeme vyvolat čekání jádra předtím, než SpinWait zahájí přepnutí kontextu. SpinWait poskytuje vlastnost NextSpinWillYield, kterou můžete zkontrolovat před každým voláním SpinOnce. Když se tato vlastnost vrátí true, spusťte vlastní operaci Wait. Pro příklad vizte Jak použít SpinWait pro implementaci čekací operace Two-Phase.

Pokud neprovádíte dvoufázovou operaci čekání, ale jen se točíte, dokud některá podmínka není pravdivá, můžete povolit SpinWait přepínání kontextu, aby byl efektivní v prostředí operačního systému Windows. Následující základní příklad ukazuje SpinWait v bezuzamčeném zásobníku. Pokud potřebujete vysoce výkonný zásobník bezpečný pro vícero vláken, zvažte použití 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

Viz také

  • Last updated on