我什么时候应该和不应该使用这个 C# 实用程序类通过 Interlocked 控制线程

我试图理解这个类的编写方式背后的逻辑，以及何时应该和不应该使用它。任何见解将不胜感激

internal struct SpinLock
{
    private volatile int lockHeld;

    private readonly static int processorCount;

    public bool IsHeld
    {
        get
        {
            return this.lockHeld != 0;
        }
    }

    static SpinLock()
    {
        SpinLock.processorCount = Environment.ProcessorCount;
    }

    public void Enter()
    {
        if (Interlocked.CompareExchange(ref this.lockHeld, 1, 0) != 0)
        {
            this.EnterSpin();
        }
    }

    private void EnterSpin()
    {
        int num = 0;
        while (this.lockHeld != null || Interlocked.CompareExchange(ref this.lockHeld, 1, 0) != 0)
        {
            if (num >= 20 || SpinLock.processorCount <= 1)
            {
                if (num >= 25)
                {
                    Thread.Sleep(1);
                }
                else
                {
                    Thread.Sleep(0);
                }
            }
            else
            {
                Thread.SpinWait(100);
            }
            num++;
        }
    }

    public void Exit()
    {
        this.lockHeld = 0;
    }
}

更新：我在源代码中找到了示例用法...这表明如何使用上述对象，尽管我不明白“为什么”

    internal class FastReaderWriterLock
    {
        private SpinLock myLock;

        private uint numReadWaiters;

        private uint numWriteWaiters;

        private int owners;

        private EventWaitHandle readEvent;

        private EventWaitHandle writeEvent;

        public FastReaderWriterLock()
        {
        }

        public void AcquireReaderLock(int millisecondsTimeout)
        {
            this.myLock.Enter();
            while (this.owners < 0 || this.numWriteWaiters != 0)
            {
                if (this.readEvent != null)
                {
                    this.WaitOnEvent(this.readEvent, ref this.numReadWaiters, millisecondsTimeout);
                }
                else
                {
                    this.LazyCreateEvent(ref this.readEvent, false);
                }
            }
            FastReaderWriterLock fastReaderWriterLock = this;
            fastReaderWriterLock.owners = fastReaderWriterLock.owners + 1;
            this.myLock.Exit();
        }

private void WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, int millisecondsTimeout)
{
    waitEvent.Reset();
    uint& numPointer = numWaiters;
    bool flag = false;
    this.myLock.Exit();
    try
    {
        if (waitEvent.WaitOne(millisecondsTimeout, false))
        {
            flag = true;
        }
        else
        {
            throw new TimeoutException("ReaderWriterLock timeout expired");
        }
    }
    finally
    {
        this.myLock.Enter();
        uint& numPointer1 = numWaiters;
        if (!flag)
        {
            this.myLock.Exit();
        }
    }
}
    }

自旋锁 http://en.wikipedia.org/wiki/Spinlock一般来说，是一种使等待线程保持唤醒状态的锁（在紧密循环中反复循环检查条件 - 想想“妈妈我们到了吗？“）而不是依赖于更重、更慢的内核模式信号。它们通常用于预期等待时间非常短的情况，在这种情况下，它们的性能优于为传统锁创建和等待操作系统句柄的开销。它们会产生更多的开销。不过，CPU 成本高于传统锁，因此传统锁（如Monitor http://msdn.microsoft.com/en-us/library/system.threading.monitor.aspx阶级或各种等待句柄 http://msdn.microsoft.com/en-us/library/system.threading.waithandle.aspx实现）是首选。

上面的代码演示了这种短等待时间的概念：

waitEvent.Reset();
// All that we are doing here is setting some variables.  
// It has to be atomic, but it's going to be *really* fast
uint& numPointer = numWaiters;
bool flag = false;
// And we are done.  No need for an OS wait handle for 2 lines of code.
this.myLock.Exit();

有一个非常好的 SpinLock内置于 BCL http://msdn.microsoft.com/en-us/library/system.threading.spinlock.aspx，但是它仅适用于 v4.0+，因此如果您使用旧版本的 .NET 框架或使用从旧版本迁移的代码，有人可能已经编写了自己的实现。

回答你的问题：如果您在 .NET 4.0 或更高版本上编写新代码，则应该使用内置 SpinLock。对于 3.5 或更早版本的代码，特别是如果您要扩展 Nesper，我认为这个实现是经过时间考验的并且是合适的。仅当您知道线程等待的时间非常短时才使用 SpinLock，如上面的示例所示。

编辑：看起来您的实现来自 Nesper - Esper CEP 库的 .NET 端口：

https://svn.codehaus.org/esper/esper/tagsnet/release_1.12.0_beta_1/trunk/NEsper/compat/SpinLock.cs https://svn.codehaus.org/esper/esper/tagsnet/release_1.12.0_beta_1/trunk/NEsper/compat/SpinLock.cs

and

https://svn.codehaus.org/esper/esper/tagsnet/release_1.12.0_beta_1/trunk/NEsper/compat/FastReaderWriterLock.cs https://svn.codehaus.org/esper/esper/tagsnet/release_1.12.0_beta_1/trunk/NEsper/compat/FastReaderWriterLock.cs

我可以确认 Nesper 早在 .NET Framework 4 出现之前就已存在，因此这就解释了对自制 SpinLock 的需求。