自旋和线程所有权及递归构成混合锁

    /// <summary>
    /// 自旋、线程所有权、递归
    /// 构成混合锁
    /// </summary>
    internal sealed class AnotherHybridLock : IDisposable
    {
        //基元用户模式构造（Interlocked的方法）使用
        private int m_waiters = 0;

        //基元内核模式构造
        //AutoResetEvent通知正在等待的线程已发生事件
        // true将初始状态设置为终止状态; false将初始状态设置为非终止
        //true有信号（不会阻塞），false无信号
        private AutoResetEvent m_waiterLock = new AutoResetEvent(false);

        //控制自旋，希望能提升性能
        //选择一个计数
        private int m_spinCount = 4000;

        //指出哪个线程拥有锁
        private int m_owningThreadId = 0;

        //指出拥有锁的线程拥有了多少次锁
        private int m_recursion = 0;

        public void Enter()
        {
            //获取当前托管线程的唯一标识符
            int threadId = Thread.CurrentThread.ManagedThreadId;

            //如果调用线程已经拥有锁
            if (threadId == m_owningThreadId)
            {
                //递增递归计数并返回
                m_recursion++;
                return;
            }

            //调用线程未拥有锁，尝试获取它
            //为基于自旋的等待提供支持
            SpinWait spinWait = new SpinWait();
            for (int spinCount = 0; spinCount < m_spinCount; spinCount++)
            {
                //第一个线程时m_waiters始终返回0，直接获得锁
                if (Interlocked.CompareExchange(ref m_waiters, 1, 0) == 0)
                {
                    goto GotLock;
                }

                //给其它线程运行的机会，希望锁会被释放
                spinWait.SpinOnce();
            }

            //自旋结束，锁仍未获得，再试一次
            //m_waiters若等于0，则1>1不成立，不必WaitOne，直接获得锁
            //否则WaitOne
            if (Interlocked.Increment(ref m_waiters) > 1)
            {
                //仍然是竞争条件，这个线程必须被阻塞
                //等待锁，性能有较大损失
                m_waiterLock.WaitOne();
                //等这个线程醒来时，它拥有锁，设置一些状态并返回
            }

            GotLock:
            //线程获得锁时，记录线程Id
            m_owningThreadId = threadId;
            //指出该线程拥有锁1次
            m_recursion = 1;
        }

        public void Leave()
        {
            //如果调用线程不拥有锁，则表明存在bug
            int threadId = Thread.CurrentThread.ManagedThreadId;
            if (threadId != m_owningThreadId)
            {
                //当某个方法要求调用方拥有给定 Monitor 上的锁并且该方法由不拥有该锁的调用方调用时引发的异常
                throw new SynchronizationLockException("Lock not owned by calling thread");
            }

            //递减递归计数
            --m_recursion;
            //如果该线程仍然拥有锁
            if (m_recursion > 0)
            {
                //直接返回
                return;
            }

            //执行到这里说明现在没有线程拥有锁
            m_owningThreadId = 0;

            //如果没有其它线程在等待则直接返回
            if (Interlocked.Decrement(ref m_waiters) == 0)
            {
                return;
            }

            //否则，有其它线程正在等待，唤醒其中一个
            //这里会有较大的性能损失
            m_waiterLock.Set();
        }

        public void Dispose()
        {
            m_waiterLock.Dispose();
        }
    }