C# SpinLock实现

关于SpinLock自旋锁网上已经有很多说明，这里也copy了一部分，我这里主要关注微软的实现，学习人家的实现方式。

如果由于垃圾回收，基于对象的锁对象开销太高，可以使用SpinLock结构。.NET 4以后版本可使用，如果你有很多个锁（如，一个列表里面的每一个节点）并且锁时间通常非常的短，使用SpinLock将很有用。你需要避免使用超过一个的SpinLock，并且不要调用任何可能阻塞的。除了架构不同，SpinLock的使用同Monitor类非常相似。通过Enter或者TryEnter请求锁，并通过Exit释放锁。SpinLock同样也通过两个属性来提供关于它当前是否已锁的信息：IsHeld和IsHeldByCurrentThread.

不要将SpinLock声明为只读字段，如果声明为只读字段，会导致每次调用都会返回一个SpinLock新副本，在多线程下，每个方法都会成功获得锁，而受到保护的临界区不会按照预期进行串行化。

SpinLock 仅当您确定这样做可以改进应用程序的性能之后才能使用。另外，务必请注意 SpinLock 是一个值类型（出于性能原因）。因此，您必须非常小心，不要意外复制了 SpinLock 实例，因为两个实例（原件和副本）之间完全独立，这可能会导致应用程序出现错误行为。如果必须传递 SpinLock 实例，则应该通过引用而不是通过值传递。

    [HostProtection(Synchronization = true, ExternalThreading = true)]
    public struct SpinLock
    {
       private volatile int m_owner;
       private const int SPINNING_FACTOR = 100;

        // After how many yields, call Sleep(1)
        private const int SLEEP_ONE_FREQUENCY = 40;

        // After how many yields, call Sleep(0)
        private const int SLEEP_ZERO_FREQUENCY = 10;

        // After how many yields, check the timeout
        private const int TIMEOUT_CHECK_FREQUENCY = 10;

        // Thr thread tracking disabled mask
        private const int LOCK_ID_DISABLE_MASK = unchecked((int)0x80000000);  

           public SpinLock(bool enableThreadOwnerTracking)
        {
            m_owner = LOCK_UNOWNED;
            if (!enableThreadOwnerTracking)
            {
                m_owner |= LOCK_ID_DISABLE_MASK;
                Contract.Assert(!IsThreadOwnerTrackingEnabled, "property should be false by now");
            }
        }

        public void TryEnter(ref bool lockTaken)
        {
            TryEnter(0, ref lockTaken);
        }
        public void TryEnter(int millisecondsTimeout, ref bool lockTaken)
        {
            int observedOwner = m_owner;
            if (millisecondsTimeout < -1 || //invalid parameter
                lockTaken || //invalid parameter
                (observedOwner & ID_DISABLED_AND_ANONYMOUS_OWNED) != LOCK_ID_DISABLE_MASK ||  //thread tracking is enabled or the lock is already acquired
                Interlocked.CompareExchange(ref m_owner, observedOwner | LOCK_ANONYMOUS_OWNED, observedOwner, ref lockTaken) != observedOwner) // acquiring the lock failed
                ContinueTryEnter(millisecondsTimeout, ref lockTaken); // The call the slow pth
        }

        private void ContinueTryEnter(int millisecondsTimeout, ref bool lockTaken)
        {
            uint startTime = 0;
            if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout != 0)
            {
                startTime = TimeoutHelper.GetTime();
            }
            if (IsThreadOwnerTrackingEnabled)
            {
                // Slow path for enabled thread tracking mode
                ContinueTryEnterWithThreadTracking(millisecondsTimeout, startTime, ref lockTaken);
                return;
            }

            // then thread tracking is disabled
            // In this case there are three ways to acquire the lock
            // 1- the first way the thread either tries to get the lock if it's free or updates the waiters, if the turn >= the processors count then go to 3 else go to 2
            // 2- In this step the waiter threads spins and tries to acquire the lock, the number of spin iterations and spin count is dependent on the thread turn
            // the late the thread arrives the more it spins and less frequent it check the lock avilability
            // Also the spins count is increases each iteration
            // If the spins iterations finished and failed to acquire the lock, go to step 3
            // 3- This is the yielding step, there are two ways of yielding Thread.Yield and Sleep(1)
            // If the timeout is expired in after step 1, we need to decrement the waiters count before returning

            int observedOwner;
            int turn = int.MaxValue;
            //***Step 1, take the lock or update the waiters

            // try to acquire the lock directly if possible or update the waiters count
            observedOwner = m_owner;
            if ((observedOwner & LOCK_ANONYMOUS_OWNED) == LOCK_UNOWNED)
            {
                if (Interlocked.CompareExchange(ref m_owner, observedOwner | 1, observedOwner, ref lockTaken) == observedOwner)
                {
                    return;
                }
            }
            else //failed to acquire the lock,then try to update the waiters. If the waiters count reached the maximum, jsut break the loop to avoid overflow
            {
                if ((observedOwner & WAITERS_MASK) != MAXIMUM_WAITERS)
                    turn = (Interlocked.Add(ref m_owner, 2) & WAITERS_MASK) >> 1 ;
            }
            // Check the timeout.
            if (millisecondsTimeout == 0 ||
                (millisecondsTimeout != Timeout.Infinite &&
                TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout) <= 0))
            {
                DecrementWaiters();
                return;
            }

            //***Step 2. Spinning
            //lock acquired failed and waiters updated
            int processorCount = PlatformHelper.ProcessorCount;
            if (turn < processorCount)
            {
                int processFactor = 1;
                for (int i = 1; i <= turn * SPINNING_FACTOR; i++)
                {
                    Thread.SpinWait((turn + i) * SPINNING_FACTOR * processFactor);
                    if (processFactor < processorCount)
                        processFactor++;
                    observedOwner = m_owner;
                    if ((observedOwner & LOCK_ANONYMOUS_OWNED) == LOCK_UNOWNED)
                    {
                        int newOwner = (observedOwner & WAITERS_MASK) == 0 ? // Gets the number of waiters, if zero
                            observedOwner | 1 // don't decrement it. just set the lock bit, it is zzero because a previous call of Exit(false) ehich corrupted the waiters
                            : (observedOwner - 2) | 1; // otherwise decrement the waiters and set the lock bit
                        Contract.Assert((newOwner & WAITERS_MASK) >= 0);

                        if (Interlocked.CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)
                        {
                            return;
                        }
                    }
                }
            }

            // Check the timeout.
            if (millisecondsTimeout != Timeout.Infinite && TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout) <= 0)
            {
                DecrementWaiters();
                return;
            }

            //*** Step 3, Yielding
            //Sleep(1) every 50 yields
            int yieldsoFar = 0;
            while (true)
            {
                observedOwner = m_owner;
                if ((observedOwner & LOCK_ANONYMOUS_OWNED) == LOCK_UNOWNED)
                {
                    int newOwner = (observedOwner & WAITERS_MASK) == 0 ? // Gets the number of waiters, if zero
                           observedOwner | 1 // don't decrement it. just set the lock bit, it is zzero because a previous call of Exit(false) ehich corrupted the waiters
                           : (observedOwner - 2) | 1; // otherwise decrement the waiters and set the lock bit
                    Contract.Assert((newOwner & WAITERS_MASK) >= 0);

                    if (Interlocked.CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)
                    {
                        return;
                    }
                }
                if (yieldsoFar % SLEEP_ONE_FREQUENCY == 0)
                {
                    Thread.Sleep(1);
                }
                else if (yieldsoFar % SLEEP_ZERO_FREQUENCY == 0)
                {
                    Thread.Sleep(0);
                }
                else
                {
                    Thread.Yield();
                }
                if (yieldsoFar % TIMEOUT_CHECK_FREQUENCY == 0)
                {
                    //Check the timeout.
                    if (millisecondsTimeout != Timeout.Infinite && TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout) <= 0)
                    {
                        DecrementWaiters();
                        return;
                    }
                }
                yieldsoFar++;
            }
        }

        private void ContinueTryEnterWithThreadTracking(int millisecondsTimeout, uint startTime, ref bool lockTaken)
        {
            Contract.Assert(IsThreadOwnerTrackingEnabled);
            int lockUnowned = 0;
            // We are using thread IDs to mark ownership. Snap the thread ID and check for recursion.
            // We also must or the ID enablement bit, to ensure we propagate when we CAS it in.
            int m_newOwner = Thread.CurrentThread.ManagedThreadId;
            if (m_owner == m_newOwner)
            {
                // We don't allow lock recursion.
                throw new LockRecursionException(Environment.GetResourceString("SpinLock_TryEnter_LockRecursionException"));
            }
            SpinWait spinner = new SpinWait();
            // Loop until the lock has been successfully acquired or, if specified, the timeout expires.
            do
            {
                // We failed to get the lock, either from the fast route or the last iteration
                // and the timeout hasn't expired; spin once and try again.
                spinner.SpinOnce();
                // Test before trying to CAS, to avoid acquiring the line exclusively unnecessarily.
                if (m_owner == lockUnowned)
                {
                    if (Interlocked.CompareExchange(ref m_owner, m_newOwner, lockUnowned, ref lockTaken) == lockUnowned)
                    {
                        return;
                    }
                }
                // Check the timeout.  We only RDTSC if the next spin will yield, to amortize the cost.
                if (millisecondsTimeout == 0 ||
                    (millisecondsTimeout != Timeout.Infinite && spinner.NextSpinWillYield &&
                    TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout) <= 0))
                {
                    return;
                }
            } while (true);
        }
        public void Exit()
        {
            //This is the fast path for the thread tracking is disabled, otherwise go to the slow path
            if ((m_owner & LOCK_ID_DISABLE_MASK) == 0)
                ExitSlowPath(true);
            else
                Interlocked.Decrement(ref m_owner);
        }

        private void ExitSlowPath(bool useMemoryBarrier)
        {
            bool threadTrackingEnabled = (m_owner & LOCK_ID_DISABLE_MASK) == 0;
            if (threadTrackingEnabled && !IsHeldByCurrentThread)
            {
                throw new System.Threading.SynchronizationLockException(
                    Environment.GetResourceString("SpinLock_Exit_SynchronizationLockException"));
            }

            if (useMemoryBarrier)
            {
                if (threadTrackingEnabled)
                    Interlocked.Exchange(ref m_owner, LOCK_UNOWNED);
                else
                    Interlocked.Decrement(ref m_owner);

            }
            else
            {
                if (threadTrackingEnabled)
                    m_owner = LOCK_UNOWNED;
                else
                {
                    int tmpOwner = m_owner;
                    m_owner = tmpOwner & (~LOCK_ANONYMOUS_OWNED);
                }

            }

        }
        public bool IsHeld
        {
            get
            {
                if (IsThreadOwnerTrackingEnabled)
                    return m_owner != LOCK_UNOWNED;
                return (m_owner & LOCK_ANONYMOUS_OWNED) != LOCK_UNOWNED;
            }
        }
        public bool IsHeldByCurrentThread
        {
            get
            {
                if (!IsThreadOwnerTrackingEnabled)
                {
                    throw new InvalidOperationException(Environment.GetResourceString("SpinLock_IsHeldByCurrentThread"));
                }
                return ((m_owner & (~LOCK_ID_DISABLE_MASK)) == Thread.CurrentThread.ManagedThreadId);
            }
        }
    }

SpinLock 构造函数有一个bool enableThreadOwnerTracking参数用来表示是否跟踪线程，如果为true，那么在获取锁以后变量m_owner就是线程ManagedThreadId属性，否者为1，因为获取锁的修改 observedOwner | 1 ，就相当于m_owner设为1，在释放锁的时候m_owner减1Interlocked.Decrement(ref m_owner) 或者设置为 Interlocked.Exchange(ref m_owner, LOCK_UNOWNED)。

SpinLock的核心方法Enter和TryEnter最终都是调用ContinueTryEnter方法，该方法首先检查IsThreadOwnerTrackingEnabled是否启用线程跟踪，如果启用就调用ContinueTryEnterWithThreadTracking方法，ContinueTryEnterWithThreadTracking方法里面实例化了一个SpinWait，然后自旋获取锁，这里也是借用原子操作【Interlocked.CompareExchange(ref m_owner, m_newOwner, lockUnowned, ref lockTaken)】，如果没有启用跟踪，那么ContinueTryEnter将分3不走，就像里面的注释描述的那样；case 1通过原子操作【Interlocked.CompareExchange(ref m_owner, observedOwner | 1, observedOwner, ref lockTaken) == observedOwner)】直接获取锁，如果失败进入到case2【turn < processorCount】，然后在循环尝试获取锁，每次循环都会调用 Thread.SpinWait方法等待；获取锁还是通过原子操作，如果失败，则进入case3，该case也是循环等待，在循环体里面不在是 Thread.SpinWait而是  Thread.Yield();和    Thread.Sleep(0);

if (yieldsoFar % 40 == 0) 
                    Thread.Sleep(1);
                else if (yieldsoFar % 10 == 0)
                    Thread.Sleep(0);
                else
                    Thread.Yield();

看到这个代码 是不是和 SpinWait相似啊。可以总结以下，case1 直接尝试获取锁，case2 循环中通过调用Thread.SpinWait 尝试获取锁【当前线程不会让出CPU】， case3循环中通过Thread.Yield()和Thread.Sleep来尝试获取锁。

Exit的方法实现就非常简单了，主要是调用ExitSlowPath，说白了就是把变量m_owner还原为初始值。