练习：自己动手实现一个轻量级的信号量（二）

话说看了Angel Lucifer兄的留言之后，发现果然Microsoft在June CTP中实现了SemaphoreSlim，其中不但考虑了与旧的同步对象在接口上的一致性，还加入了Cancellation的检查。唉，怪我没有跟上形势！那么这篇就成班门弄斧了。不过，还应该坚持把它写完，善始善终，就当为大家整理思路。取笑罢了:-)

上一次说到用户态与内核态切换带来的开销平均水平是600个时钟周期！因此，如果在大部分时间内。各个线程对同步对象操作时间非常短暂的情况下，可以先自旋一段时间，避免直接进入内核模式，在自旋无果的情况下再进入真正的等待。（这里插一句：可能我说的不清楚，造成了大家的误解，实际上获得一个CriticalSection的操作在用户态就可以完成了，但是，一旦锁已经被其他线程持有而需要进入等待时，一定会切换到内核模式。这就是为什么说使用自旋可以极大限度的避免每次都切换到内核模式的原因）。Intel的《多核程序设计》一书中就提到，在多核处理器平台，可以使用

BOOL WINAPI InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount);

初始化CriticalSection对象，使其在进入真正等待之前进行短暂的自旋而不是直接进入等待状态，也是这个意思。

好的，首先看看我们在什么地方需要进行自旋等待。很显然就是在Wait刚刚开始，需要获得锁的时候。为了方便，将上一篇中的源代码摘抄过来。

 1 public bool Wait(int millisecondsTimeout, int waitResNumber)
 2 {
 3     // 参数检查工作是必须的
 4     if (millisecondsTimeout < -1)
 5         throw new ArgumentOutOfRangeException("millisecondsTimeout");
 6     if (waitResNumber < 1)
 7         throw new ArgumentOutOfRangeException("waitResNumber");
 8     // 我们在后面要两次处理超时，因此我们需要一个计时器
 9     System.Diagnostics.StopWatch watch = null;
     int timeoutNum = millisecondsTimeout;
     if (millisecondsTimeout != -1)
     {
         watch = System.Diagnostics.Stopwatch.StartNew();
     }
     // 现在我们来做第（1）步
     if (!System.Threading.Monitor.TryEnter(this._globalLock))
     {
         if (millisecondsTimeout == 0)
             return false;
         /////////////////////////////////////////////////
         // 就是在这里，我们需要先自旋一下，然后再进入真正的等待 //
         /////////////////////////////////////////////////
         if (!System.Threading.Monitor.TryEnter(this._globalLock, millisecondsTimeout))
         {
             return false;
         }
     }
     // 现在我们已经获得锁了，我们要增加阻塞的线程数目，以便将来有人能够唤醒我们
     ++this._waitingThreadCount;
     try
     {
         // 如果当前的资源数目不够用的，我们就得等等了
         while (this._currentResources - waitResNumber < 0)
         {
             if (millisecondsTimeout != -1)
             {
                 // 看看是不是超时了
                 timeoutNum = UpdateTimeout(watch, millisecondsTimeout);
                 if (timeoutNum <= 0)
                 {
                     return false;
                 }
             }
             // 如果没有超时我们就再等一下
             if (!System.Threading.Monitor.Wait(this._globalLock, timeoutNum))
             {
                 return false;
             }
             // 好的我们被唤醒了，赶快回去检查检查有没有足够的资源了
         }
         // 很好，我们现在有足够的资源了，
         // 并且没有什么人能够再更改资源数目了，因为锁在我们手里！
         this._currentResources -= waitResNumber;
     }
     finally
     {
         // 很好，我们安全的退出了，减少阻塞的线程数目并且释放锁
         --this._waitingThreadCount;
         System.Threading.Monitor.Exit(this._globalLock);
     }
     return true;
 }
 
 

 

直接在上面添加一个Thread.SpinWait并不很好，因为如果一次Spin的时间较长，就无谓的浪费了时间，而过短又不能避免进入真正的等待状态，所以最好是分几次来Spin，这样，在每一次的间歇我们还是可以检查是否我们已经获得了锁。自然，要多加上一个循环：

 1 public bool Wait(int millisecondsTimeout, int waitResNumber)
 2 {
 3     // 参数检查工作是必须的
 4     if (millisecondsTimeout < -1)
 5         throw new ArgumentOutOfRangeException("millisecondsTimeout");
 6     if (waitResNumber < 1)
 7         throw new ArgumentOutOfRangeException("waitResNumber");
 8     // 我们在后面要两次处理超时，因此我们需要一个计时器
 9     System.Diagnostics.Stopwatch watch = null;
     int timeoutNum = millisecondsTimeout;
     if (millisecondsTimeout != -1)
     {
         watch = System.Diagnostics.Stopwatch.StartNew();
     }
     // 现在我们来做第（1）步
     // 这个值实际上很有讲究，可惜这个地方我没有做很多的测试
     int spinThreshold = 20;
     while (true)
     {
         if (!System.Threading.Monitor.TryEnter(this._globalLock))
         {
             // 如果不允许超时设置则一次获得失败就直接退出
             if (millisecondsTimeout == 0)
                 return false;
             // 如果不是无限等待每次循环都更新时间看看有没有超时
             else if (millisecondsTimeout != -1)
             {
                 timeoutNum = UpdateTimeout(watch, millisecondsTimeout);
                 if (timeoutNum <= 0)
                     return false;
             }
             if (spinThreshold <= 0)
             {
                 // 如果自选完毕了就进入真正的等待
                 if (!System.Threading.Monitor.TryEnter(this._globalLock, millisecondsTimeout))
                 {
                     return false;
                 }
                 else
                 {
                     // 我们最终还是获得了锁
                     break;
                 }
             }
             else
             {
                 // 退避自旋
                 System.Threading.Thread.SpinWait(21 - spinThreshold);
                 --spinThreshold;
             }
         }
         else
         {
             // 很幸运，第一次就获得了锁！
             break;
         }
     }
     // 现在我们已经获得锁了，我们要增加阻塞的线程数目，以便将来有人能够唤醒我们
     ++this._waitingThreadCount;
     try
     {
         // 如果当前的资源数目不够用的，我们就得等等了
         while (this._currentResources - waitResNumber < 0)
         {
             if (millisecondsTimeout != -1)
             {
                 // 看看是不是超时了
                 timeoutNum = UpdateTimeout(watch, millisecondsTimeout);
                 if (timeoutNum <= 0)
                 {
                     return false;
                 }
             }
             // 如果没有超时我们就再等一下
             if (!System.Threading.Monitor.Wait(this._globalLock, timeoutNum))
             {
                 return false;
             }
             // 好的我们被唤醒了，赶快回去检查检查有没有足够的资源了
         }
         // 很好，我们现在有足够的资源了，
         // 并且没有什么人能够再更改资源数目了，因为锁在我们手里！
         this._currentResources -= waitResNumber;
     }
     finally
     {
         // 很好，我们安全的退出了，减少阻塞的线程数目并且释放锁
         --this._waitingThreadCount;
         System.Threading.Monitor.Exit(this._globalLock);
     }
     return true;
 }

 

这样我们就针对锁的获得加入了自旋优化，充分避免直接进入等待锁的状态。

剩下的就是以秋风扫落叶之势编写余下的代码了！整体代码如下：

  1public class SemaphoreExtended
  2{
  3    private object _globalLock;
  4    private volatile int _currentResources;
  5    private int _initResources;
  6    private readonly int _maxResourceCount;
  7    private int _waitingThreadCount;
  8
  9    public int CurrentResourceCount
 10    {
 11        get { return this._currentResources; }
 12    }
 13
 14    public SemaphoreExtended(int initialResCount, int maxResCount)
 15    {
 16        if ((initialResCount < 0) || (initialResCount > maxResCount))
 17            throw new ArgumentOutOfRangeException("initialCount");
 18        if (maxResCount <= 0)
 19            throw new ArgumentOutOfRangeException("maxCount");
 20        this._initResources = initialResCount;
 21        this._maxResourceCount = maxResCount;
 22        this._globalLock = new object();
 23        this._currentResources = this._initResources;
 24    }
 25
 26    public SemaphoreExtended(int initialResCount)
 27        : this(initialResCount, int.MaxValue)
 28    {
 29    }
 30
 31    private void VerifyDispose()
 32    {
 33        if (this._globalLock == null)
 34        {
 35            throw new ObjectDisposedException("SemaphoreExtended");
 36        }
 37    }
 38
 39    public int Release(int releaseResCount)
 40    {
 41        this.VerifyDispose();
 42        if (releaseResCount < 1)
 43            throw new ArgumentOutOfRangeException("releaseCount");
 44        lock (this._globalLock)
 45        {
 46            if (this._maxResourceCount - this._currentResources < releaseResCount)
 47            {
 48                throw new System.Threading.SemaphoreFullException();
 49            }
 50            int old = this._currentResources;
 51            this._currentResources += releaseResCount;
 52            if (this._waitingThreadCount == 1)
 53            {
 54                System.Threading.Monitor.Pulse(this._globalLock);
 55            }
 56            else if (this._waitingThreadCount > 1)
 57            {
 58                System.Threading.Monitor.PulseAll(this._globalLock);
 59            }
 60            return old;
 61        }
 62    }
 63
 64    public int Release()
 65    {
 66        return this.Release(1);
 67    }
 68
 69    public bool Wait(int millisecondsTimeout, int waitResNumber)
 70    {
 71        this.VerifyDispose();
 72        if (millisecondsTimeout < -1)
 73            throw new ArgumentOutOfRangeException("millisecondsTimeout");
 74        if (waitResNumber < 1)
 75            throw new ArgumentOutOfRangeException("waitResNumber");
 76        System.Diagnostics.Stopwatch watch = null;
 77        int timeoutNum = millisecondsTimeout;
 78        if (millisecondsTimeout != -1)
 79        {
 80            watch = System.Diagnostics.Stopwatch.StartNew();
 81        }
 82        int spinThreshold = 20;
 83        while (true)
 84        {
 85            if (!System.Threading.Monitor.TryEnter(this._globalLock))
 86            {
 87                if (millisecondsTimeout == 0)
 88                    return false;
 89                else if (millisecondsTimeout != -1)
 90                {
 91                    timeoutNum = UpdateTimeout(watch, millisecondsTimeout);
 92                    if (timeoutNum <= 0)
 93                        return false;
 94                }
 95                if (spinThreshold <= 0)
 96                {
 97                    if (!System.Threading.Monitor.TryEnter(this._globalLock, millisecondsTimeout))
 98                    {
 99                        return false;
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    System.Threading.Thread.SpinWait(21 - spinThreshold);
                    --spinThreshold;
                }
            }
            else
            {
                break;
            }
        }
        ++this._waitingThreadCount;
        try
        {
            while (this._currentResources - waitResNumber < 0)
            {
                if (millisecondsTimeout != -1)
                {
                    timeoutNum = UpdateTimeout(watch, millisecondsTimeout);
                    if (timeoutNum <= 0)
                    {
                        return false;
                    }
                }
                if (!System.Threading.Monitor.Wait(this._globalLock, timeoutNum))
                {
                    return false;
                }
            }
            this._currentResources -= waitResNumber;
        }
        finally
        {
            --this._waitingThreadCount;
            System.Threading.Monitor.Exit(this._globalLock);
        }

        return true;
    }

    public bool Wait(int millisecondsTimeout)
    {
        return this.Wait(millisecondsTimeout, 1);
    }

    private static int UpdateTimeout(System.Diagnostics.Stopwatch watch, int orgWaittime)
    {
        if (watch.ElapsedMilliseconds > int.MaxValue) return 0;
        int rtn = orgWaittime - (int)watch.ElapsedMilliseconds;
        if (rtn <= 0) return 0;
        return rtn;
    }
}

上面有一处小小的改动。就是_waitingThreadCount取消了volatile修饰，因为我们对于这个变量的更新以及获得均在lock中，已经包含了适当的barrier，因此没有必要将其声明为volatile了。相反的，_currentResourceCount 就需要声明为 volatile 以保证其有acquire语义。

回头再看一下微软实现的SemaphoreSlim，确实考虑的很周到，不但考虑了Cancellation（但是很奇怪，一个Semaphore一旦取消之后就貌似不可能重新恢复了，只有Dispose之后再用另一个！）而且考虑了与原有的同步对象的兼容性，方便代码移植。继承自WaitHandle，在需要使用内核对象时Lazy创建并使用内核对象，而在不使用WaitHandle的情况下，使用Monitor对Semaphore进行模拟。在这一点上，确实应当学习Microsoft，多从用户（对于Library，程序员就是用户啊）的角度考虑。毕竟得用户者得天下啊。（在东西不是很贵的前提下，哈哈:-D）