多线程中的锁系统(四)-谈谈自旋锁

阅读目录：

1. 基础
2. 自旋锁示例
3. SpinLock
4. 继续SpinLock
5. 总结

基础

内核锁：基于内核对象构造的锁机制，就是通常说的内核构造模式。用户模式构造和内核模式构造

优点：cpu利用最大化。它发现资源被锁住，请求就排队等候。线程切换到别处干活，直到接受到可用信号，线程再切回来继续处理请求。

缺点：托管代码->用户模式代码->内核代码损耗、线程上下文切换损耗。

在锁的时间比较短时，系统频繁忙于休眠、切换，是个很大的性能损耗。

自旋锁：原子操作+自循环。通常说的用户构造模式。 线程不休眠，一直循环尝试对资源访问，直到可用。

优点：完美解决内核锁的缺点。

缺点：长时间一直循环会导致cpu的白白浪费，高并发竞争下、CPU的消耗特别严重。

混合锁：内核锁+自旋锁。混合锁是先自旋锁一段时间或自旋多少次，再转成内核锁。

优点：内核锁和自旋锁的折中方案，利用前二者优点，避免出现极端情况（自旋时间过长，内核锁时间过短）。

缺点： 自旋多少时间、自旋多少次，这些策略很难把控。

在操作系统及net框架层，这块算法策略做的已经非常优了，有些API函数也提供了时间及次数可配置项，让使用者根据需求自行判断。

自旋锁示例

来看下我们自己简单实现的自旋锁：

  　　　　　 int signal = 0;            var li = new List<int>();            Parallel.For(0, 1000 * 10000, r =>            {                while (Interlocked.Exchange(ref signal, 1) != 0)//加自旋锁                {                    //黑魔法                }                li.Add(r);                Interlocked.Exchange(ref signal, 0);  //释放锁            });            Console.WriteLine(li.Count);            //输出：10000000

上面就是自旋锁：Interlocked.Exchange+while

1：定义signal 0可用，1不可用。

2：Parallel模拟并发竞争，原子更改signal状态。 后续线程自旋访问signal，是否可用。

3：A线程使用完后，更改signal为0。 剩余线程竞争访问资源，B线程胜利后，更改signal为1，失败线程继续自旋，直到可用。

SpinLock

SpinLock是net4.0后Net提供的自旋锁类库，内部做了优化。

简单看下实例：

  var li = new List<int>();            var sl = new SpinLock();            Parallel.For(0, 1000 * 10000, r =>            {                bool gotLock = false;     //释放成功                sl.Enter(ref gotLock);    //进入锁                li.Add(r);                if (gotLock) sl.Exit();  //释放            });            Console.WriteLine(li.Count);            //输出：10000000

继续SpinLock

new SpinLock(false) 这个构造函数主要用来检查死锁用，true是开启。

在开启状态下，一旦发生死锁会直接抛异常的。

SpinLock实现的部分源码：

  public void Enter(ref bool lockTaken)         {            if (lockTaken)             {                 lockTaken = false;                throw new System.ArgumentException(Environment.GetResourceString("SpinLock_TryReliableEnter_ArgumentException"));             }            // Fast path to acquire the lock if the lock is released            // If the thread tracking enabled set the new owner to the current thread id             // Id not, set the anonymous bit lock            int observedOwner = m_owner;             int newOwner = 0;             bool threadTrackingEnabled = (m_owner & LOCK_ID_DISABLE_MASK) == 0;            if (threadTrackingEnabled)             {                if (observedOwner == LOCK_UNOWNED)                    newOwner = Thread.CurrentThread.ManagedThreadId;            }             else if ((observedOwner & LOCK_ANONYMOUS_OWNED) == LOCK_UNOWNED)            {                 newOwner = observedOwner | LOCK_ANONYMOUS_OWNED; // set the lock bit             }            if (newOwner != 0)             {#if !FEATURE_CORECLR                Thread.BeginCriticalRegion();#endif #if PFX_LEGACY_3_5                 if (Interlocked.CompareExchange(ref m_owner, newOwner, observedOwner) == observedOwner)                 {                    lockTaken = true;                     return;                }#else                if (Interlocked.CompareExchange(ref m_owner, newOwner, observedOwner, ref lockTaken) == observedOwner)                 {                    // Fast path succeeded                     return;                 }#endif #if !FEATURE_CORECLR                Thread.EndCriticalRegion();#endif            }             //Fast path failed, try slow path            ContinueTryEnter(Timeout.Infinite, ref lockTaken);         } PRivate void ContinueTryEnter(int millisecondsTimeout, ref bool lockTaken)        {             long startTicks = 0;             if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout != 0)            {                 startTicks = DateTime.UtcNow.Ticks;            }#if !FEATURE_PAL && !FEATURE_CORECLR   // PAL doesn't support  eventing, and we don't compile CDS providers for Coreclr             if (CdsSyncEtwBCLProvider.Log.IsEnabled())            {                 CdsSyncEtwBCLProvider.Log.SpinLock_FastPathFailed(m_owner);             }#endif             if (IsThreadOwnerTrackingEnabled)            {                // Slow path for enabled thread tracking mode                 ContinueTryEnterWithThreadTracking(millisecondsTimeout, startTicks, 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 increaes 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;            //***Step 1, take the lock or update the waiters             // try to acquire the lock directly if possoble or update the waiters count            SpinWait spinner = new SpinWait();             while (true)             {                observedOwner = m_owner;                 if ((observedOwner & LOCK_ANONYMOUS_OWNED) == LOCK_UNOWNED)                {#if !FEATURE_CORECLR                    Thread.BeginCriticalRegion(); #endif #if PFX_LEGACY_3_5                     if (Interlocked.CompareExchange(ref m_owner, observedOwner | 1, observedOwner) == observedOwner)                    {                         lockTaken = true;                        return;                    }#else                     if (Interlocked.CompareExchange(ref m_owner, observedOwner | 1, observedOwner, ref lockTaken) == observedOwner)                    {                         return;                     }#endif #if !FEATURE_CORECLR                    Thread.EndCriticalRegion();#endif                 }                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 || Interlocked.CompareExchange(ref m_owner, observedOwner + 2, observedOwner) == observedOwner)                         break;                 spinner.SpinOnce();            }            // Check the timeout.             if (millisecondsTimeout == 0 ||                (millisecondsTimeout != Timeout.Infinite &&                 TimeoutExpired(startTicks, millisecondsTimeout)))             {                DecrementWaiters();                 return;            }            //***Step 2. Spinning             //lock acquired failed and waiters updated            int turn = ((observedOwner + 2) & WAITERS_MASK) / 2;             int processorCount = PlatformHelper.ProcessorCount;             if (turn < processorCount)            {                 int processFactor = 1;                for (int i = 1; i <= turn * SPINNING_FACTOR; i++)                {                    Thread.SpinWai