SpinLock Yapı

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kod:

System.Threading.dll

Kaynak:

SpinLock.cs

Kilidi almaya çalışan bir iş parçacığının, kilit kullanılabilir duruma gelene kadar sürekli olarak denetlenen bir döngüde beklediği karşılıklı bir dışlama kilidi temel öğesi sağlar.

public value class SpinLock

public struct SpinLock

type SpinLock = struct

Public Structure SpinLock

Devralma

Object

ValueType

SpinLock

Örnekler

Aşağıdaki örnekte bir 'nin nasıl kullanılacağı gösterilmektedir SpinLock:

using System;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

class SpinLockDemo
{

    // Demonstrates:
    //      Default SpinLock construction ()
    //      SpinLock.Enter(ref bool)
    //      SpinLock.Exit()
    static void SpinLockSample1()
    {
        SpinLock sl = new SpinLock();

        StringBuilder sb = new StringBuilder();

        // Action taken by each parallel job.
        // Append to the StringBuilder 10000 times, protecting
        // access to sb with a SpinLock.
        Action action = () =>
        {
            bool gotLock = false;
            for (int i = 0; i < 10000; i++)
            {
                gotLock = false;
                try
                {
                    sl.Enter(ref gotLock);
                    sb.Append((i % 10).ToString());
                }
                finally
                {
                    // Only give up the lock if you actually acquired it
                    if (gotLock) sl.Exit();
                }
            }
        };

        // Invoke 3 concurrent instances of the action above
        Parallel.Invoke(action, action, action);

        // Check/Show the results
        Console.WriteLine("sb.Length = {0} (should be 30000)", sb.Length);
        Console.WriteLine("number of occurrences of '5' in sb: {0} (should be 3000)",
            sb.ToString().Where(c => (c == '5')).Count());
    }

    // Demonstrates:
    //      Default SpinLock constructor (tracking thread owner)
    //      SpinLock.Enter(ref bool)
    //      SpinLock.Exit() throwing exception
    //      SpinLock.IsHeld
    //      SpinLock.IsHeldByCurrentThread
    //      SpinLock.IsThreadOwnerTrackingEnabled
    static void SpinLockSample2()
    {
        // Instantiate a SpinLock
        SpinLock sl = new SpinLock();

        // These MRESs help to sequence the two jobs below
        ManualResetEventSlim mre1 = new ManualResetEventSlim(false);
        ManualResetEventSlim mre2 = new ManualResetEventSlim(false);
        bool lockTaken = false;

        Task taskA = Task.Factory.StartNew(() =>
        {
            try
            {
                sl.Enter(ref lockTaken);
                Console.WriteLine("Task A: entered SpinLock");
                mre1.Set(); // Signal Task B to commence with its logic

                // Wait for Task B to complete its logic
                // (Normally, you would not want to perform such a potentially
                // heavyweight operation while holding a SpinLock, but we do it
                // here to more effectively show off SpinLock properties in
                // taskB.)
                mre2.Wait();
            }
            finally
            {
                if (lockTaken) sl.Exit();
            }
        });

        Task taskB = Task.Factory.StartNew(() =>
        {
            mre1.Wait(); // wait for Task A to signal me
            Console.WriteLine("Task B: sl.IsHeld = {0} (should be true)", sl.IsHeld);
            Console.WriteLine("Task B: sl.IsHeldByCurrentThread = {0} (should be false)", sl.IsHeldByCurrentThread);
            Console.WriteLine("Task B: sl.IsThreadOwnerTrackingEnabled = {0} (should be true)", sl.IsThreadOwnerTrackingEnabled);

            try
            {
                sl.Exit();
                Console.WriteLine("Task B: Released sl, should not have been able to!");
            }
            catch (Exception e)
            {
                Console.WriteLine("Task B: sl.Exit resulted in exception, as expected: {0}", e.Message);
            }

            mre2.Set(); // Signal Task A to exit the SpinLock
        });

        // Wait for task completion and clean up
        Task.WaitAll(taskA, taskB);
        mre1.Dispose();
        mre2.Dispose();
    }

    // Demonstrates:
    //      SpinLock constructor(false) -- thread ownership not tracked
    static void SpinLockSample3()
    {
        // Create SpinLock that does not track ownership/threadIDs
        SpinLock sl = new SpinLock(false);

        // Used to synchronize with the Task below
        ManualResetEventSlim mres = new ManualResetEventSlim(false);

        // We will verify that the Task below runs on a separate thread
        Console.WriteLine("main thread id = {0}", Thread.CurrentThread.ManagedThreadId);

        // Now enter the SpinLock.  Ordinarily, you would not want to spend so
        // much time holding a SpinLock, but we do it here for the purpose of 
        // demonstrating that a non-ownership-tracking SpinLock can be exited 
        // by a different thread than that which was used to enter it.
        bool lockTaken = false;
        sl.Enter(ref lockTaken);

        // Create a separate Task from which to Exit() the SpinLock
        Task worker = Task.Factory.StartNew(() =>
        {
            Console.WriteLine("worker task thread id = {0} (should be different than main thread id)",
                Thread.CurrentThread.ManagedThreadId);

            // Now exit the SpinLock
            try
            {
                sl.Exit();
                Console.WriteLine("worker task: successfully exited SpinLock, as expected");
            }
            catch (Exception e)
            {
                Console.WriteLine("worker task: unexpected failure in exiting SpinLock: {0}", e.Message);
            }

            // Notify main thread to continue
            mres.Set();
        });

        // Do this instead of worker.Wait(), because worker.Wait() could inline the worker Task,
        // causing it to be run on the same thread.  The purpose of this example is to show that
        // a different thread can exit the SpinLock created (without thread tracking) on your thread.
        mres.Wait();

        // now Wait() on worker and clean up
        worker.Wait();
        mres.Dispose();
    }
}

Imports System.Text
Imports System.Threading
Imports System.Threading.Tasks


Module SpinLockDemo

    ' Demonstrates:
    ' Default SpinLock construction ()
    ' SpinLock.Enter(ref bool)
    ' SpinLock.Exit()
    Private Sub SpinLockSample1()
        Dim sl As New SpinLock()

        Dim sb As New StringBuilder()

        ' Action taken by each parallel job.
        ' Append to the StringBuilder 10000 times, protecting
        ' access to sb with a SpinLock.
        Dim action As Action =
            Sub()
                Dim gotLock As Boolean = False
                For i As Integer = 0 To 9999
                    gotLock = False
                    Try
                        sl.Enter(gotLock)
                        sb.Append((i Mod 10).ToString())
                    Finally
                        ' Only give up the lock if you actually acquired it
                        If gotLock Then
                            sl.[Exit]()
                        End If
                    End Try
                Next
            End Sub

        ' Invoke 3 concurrent instances of the action above
        Parallel.Invoke(action, action, action)

        ' Check/Show the results
        Console.WriteLine("sb.Length = {0} (should be 30000)", sb.Length)
        Console.WriteLine("number of occurrences of '5' in sb: {0} (should be 3000)", sb.ToString().Where(Function(c) (c = "5"c)).Count())
    End Sub

    ' Demonstrates:
    ' Default SpinLock constructor (tracking thread owner)
    ' SpinLock.Enter(ref bool)
    ' SpinLock.Exit() throwing exception
    ' SpinLock.IsHeld
    ' SpinLock.IsHeldByCurrentThread
    ' SpinLock.IsThreadOwnerTrackingEnabled
    Private Sub SpinLockSample2()
        ' Instantiate a SpinLock
        Dim sl As New SpinLock()

        ' These MRESs help to sequence the two jobs below
        Dim mre1 As New ManualResetEventSlim(False)
        Dim mre2 As New ManualResetEventSlim(False)
        Dim lockTaken As Boolean = False

        Dim taskA As Task = Task.Factory.StartNew(
            Sub()
                Try
                    sl.Enter(lockTaken)
                    Console.WriteLine("Task A: entered SpinLock")
                    mre1.[Set]()
                    ' Signal Task B to commence with its logic
                    ' Wait for Task B to complete its logic
                    ' (Normally, you would not want to perform such a potentially
                    ' heavyweight operation while holding a SpinLock, but we do it
                    ' here to more effectively show off SpinLock properties in
                    ' taskB.)
                    mre2.Wait()
                Finally
                    If lockTaken Then
                        sl.[Exit]()
                    End If
                End Try
            End Sub)

        Dim taskB As Task = Task.Factory.StartNew(
            Sub()
                mre1.Wait()
                ' wait for Task A to signal me
                Console.WriteLine("Task B: sl.IsHeld = {0} (should be true)", sl.IsHeld)
                Console.WriteLine("Task B: sl.IsHeldByCurrentThread = {0} (should be false)", sl.IsHeldByCurrentThread)
                Console.WriteLine("Task B: sl.IsThreadOwnerTrackingEnabled = {0} (should be true)", sl.IsThreadOwnerTrackingEnabled)

                Try
                    sl.[Exit]()
                    Console.WriteLine("Task B: Released sl, should not have been able to!")
                Catch e As Exception
                    Console.WriteLine("Task B: sl.Exit resulted in exception, as expected: {0}", e.Message)
                End Try

                ' Signal Task A to exit the SpinLock
                mre2.[Set]()
            End Sub)

        ' Wait for task completion and clean up
        Task.WaitAll(taskA, taskB)
        mre1.Dispose()
        mre2.Dispose()
    End Sub

    ' Demonstrates:
    ' SpinLock constructor(false) -- thread ownership not tracked
    Private Sub SpinLockSample3()
        ' Create SpinLock that does not track ownership/threadIDs
        Dim sl As New SpinLock(False)

        ' Used to synchronize with the Task below
        Dim mres As New ManualResetEventSlim(False)

        ' We will verify that the Task below runs on a separate thread
        Console.WriteLine("main thread id = {0}", Thread.CurrentThread.ManagedThreadId)

        ' Now enter the SpinLock.  Ordinarily, you would not want to spend so
        ' much time holding a SpinLock, but we do it here for the purpose of 
        ' demonstrating that a non-ownership-tracking SpinLock can be exited 
        ' by a different thread than that which was used to enter it.
        Dim lockTaken As Boolean = False
        sl.Enter(lockTaken)

        ' Create a separate Task
        Dim worker As Task = Task.Factory.StartNew(
            Sub()
                Console.WriteLine("worker task thread id = {0} (should be different than main thread id)", Thread.CurrentThread.ManagedThreadId)

                ' Now exit the SpinLock
                Try
                    sl.[Exit]()
                    Console.WriteLine("worker task: successfully exited SpinLock, as expected")
                Catch e As Exception
                    Console.WriteLine("worker task: unexpected failure in exiting SpinLock: {0}", e.Message)
                End Try

                ' Notify main thread to continue
                mres.[Set]()
            End Sub)

        ' Do this instead of worker.Wait(), because worker.Wait() could inline the worker Task,
        ' causing it to be run on the same thread. The purpose of this example is to show that
        ' a different thread can exit the SpinLock created (without thread tracking) on your thread.
        mres.Wait()

        ' now Wait() on worker and clean up
        worker.Wait()
        mres.Dispose()
    End Sub


End Module

Açıklamalar

Spin Lock kullanma örneği için bkz. How to: Use SpinLock for Low-Level Synchronization.

Döndürme kilitleri, boyut olarak veya çöp toplama baskısı nedeniyle kullanılarak ima edilen Monitornesne ayırmanın aşırı pahalı olduğu yaprak düzeyi kilitler için kullanılabilir. Bir spin kilidi engellemeyi önlemek için yararlı olabilir; ancak, önemli miktarda engelleme bekliyorsanız, büyük olasılıkla aşırı dönen nedeniyle döndürme kilitleri kullanmamalısınız. Kilitler ayrıntılı ve sayıca büyük olduğunda (örneğin, bağlı bir listedeki düğüm başına bir kilit) ve ayrıca kilit tutma süreleri her zaman çok kısa olduğunda döndürme yararlı olabilir. Genel olarak, bir spin kilidi tutarken, şu eylemlerden herhangi birinden kaçınılmalıdır:

• Engelleme

• engelleyebilecek her şeyi çağırmak,

• bir kerede birden fazla spin kilidi tutma,

• dinamik olarak dağıtılan çağrılar yapma (arabirim ve sanallar),

• sahip olmadığı herhangi bir koda statik olarak dağıtılan çağrılar yapmak veya

• bellek ayırma.

SpinLock yalnızca uygulamanın performansını artıracağı belirlendikten sonra kullanılmalıdır. Performans nedenleriyle bir değer türü olduğuna SpinLock dikkat etmek de önemlidir. Bu nedenle, iki örnek (özgün ve kopya) birbirinden tamamen bağımsız olacağından ve uygulamanın hatalı davranışına yol açacağı için, bir örneği yanlışlıkla kopyalamamaya SpinLock dikkat etmeniz gerekir. Bir SpinLock örnek etrafında geçirilmesi gerekiyorsa, değer yerine başvuruyla geçirilmelidir.

Örnekleri salt okunur alanlarda depolamayın SpinLock .

Oluşturucular

SpinLock(Boolean)

Hata ayıklamayı SpinLock geliştirmek için iş parçacığı kimliklerini izleme seçeneğiyle yapının yeni bir örneğini başlatır.

Özellikler

IsHeld	Kilidin şu anda herhangi bir iş parçacığı tarafından tutulup tutulmadığını alır.
IsHeldByCurrentThread	Kilidin geçerli iş parçacığı tarafından tutulup tutulmadığını alır.
IsThreadOwnerTrackingEnabled	Bu örnek için iş parçacığı sahipliği izlemenin etkinleştirilip etkinleştirilmediğini alır.

Yöntemler

Enter(Boolean)	Kilidi güvenilir bir şekilde alır, böylece yöntem çağrısında bir özel durum oluşsa bile kilidin lockTaken alınıp alınmadığını belirlemek için güvenilir bir şekilde incelenebilir.
Exit()	Kilidi serbest bırakır.
Exit(Boolean)	Kilidi serbest bırakır.
TryEnter(Boolean)	Yöntemi çağrısında lockTaken bir özel durum oluşsa bile kilidin alınıp alınmadığını belirlemek için güvenilir bir şekilde kilidi alma girişimleri güvenilir bir şekilde incelenebilir.
TryEnter(Int32, Boolean)	Yöntemi çağrısında lockTaken bir özel durum oluşsa bile kilidin alınıp alınmadığını belirlemek için güvenilir bir şekilde kilidi alma girişimleri güvenilir bir şekilde incelenebilir.
TryEnter(TimeSpan, Boolean)	Yöntemi çağrısında lockTaken bir özel durum oluşsa bile kilidin alınıp alınmadığını belirlemek için güvenilir bir şekilde kilidi alma girişimleri güvenilir bir şekilde incelenebilir.

İş Parçacığı Güvenliği

tüm üyeleri SpinLock iş parçacığı açısından güvenlidir ve aynı anda birden çok iş parçacığından kullanılabilir.

Ayrıca bkz.

• SpinLock
• Nasıl yapılır: Düşük düzeyli eşitleme için SpinLock kullanma
• Nasıl yapılır: SpinLock'ta Thread-Tracking Modunu Etkinleştirme