使用监视器查找以下信号量实现的错误

Question

在一次采访中被要求找出以下代码中的错误，如果有的话。
class 下面实现了具有一定容量的信号量。

    public class MySemaphore
    {
        private object _mutex = new object();
        private int _currAvail;

        public MySemaphore(int capacity)
        {
            _currAvail​ = capacity;
        }

        public void Wait()
        {
            lock (_mutex)
            {
                if (_currAvail == 0) Monitor.Wait(_mutex);
                _currAvail--;
            }
        }

        public void Signal()
        {
            lock (_mutex) {
                _currAvail​++;
                Monitor.Pulse(_mutex);
            }
        }

    }

Answer 1

我可以看到这个信号量的问题：

• capacity实际上只是初始容量，而不是总容量。 因此，一个人只需调用Signal 1000 次并拥有 1000 个额外容量。
• integer 溢出未处理。 如果您将int.MaxValue作为初始容量，然后是Signal ，您当前的容量将为int.MinValue 。
• 构造函数不检查传入的 int 是否为负

Answer 2

全面披露：我不使用 C#。 我不熟悉Monitor.Wait(o)和Monitor.Pulse(o) ，但我相信如果允许两个或多个线程同时调用sema.Wait() ， _currAvail可能 go 为负数。

假设线程 A 和线程 C 同时调用sema.Wait()而线程 B 调用sema.Signal() 。 以下是我认为可能发生的情况：

currAvail  mutex   Thread A       Thread B        Thread C
---------  -----   -------------  --------------  --------------
    0      free    lock(mutex)         .               .
    0        A     Await Pulse()  Await mutex          .
    0      free      ''    ''     lock(mutex)          .
    0        B       ''    ''     currAvail++     Await mutex
    1        B       ''    ''     Pulse()          ''    ''

    1        B     Await mutex    release(mutex)   ''    ''
    1      free      ''    ''          .          lock(mutex)
    1        C       ''    ''          .          curAvail--
    0        C       ''    ''          .          release(mutex)
    0      free      ''    ''          .               .

    0      free    lock(mutex)         .               .
    0        A     currAvail--         .               .
   -1        A     release(mutex)      .               .
   -1      free          .             .               .

修复方法是在Monitor.Wait(_mutex)返回后重新检查_currAvail 。 即，在循环中调用Monitor.Wait(_mutex) ：

lock (_mutex) {
    while (_currAvail == 0) Monitor.Wait(_mutex);
    _currAvail--;
}