深入多线程之:用Wait与Pulse模拟一些同步构造的应用详解

你可能在上篇文章中《》注意到了这个模式：两个waiting 循环都要下面的构造：

lock(_locker)
{
        while(!_flag) monitor.wait(_locker);
        _flag = false;
}

在这里_flag被另一线程设置为true。这是，从作用上讲，这里在模仿autoresetevent。如果我们将 _flag = false;去掉，那么我们就得到了一个基本的manualresetevent.

让我们使用wait和pulse来为manualresetevent完成剩余的代码吧。

readonly object _locker = new object();
        bool _signal;

        void waitone()
        {
            lock (_locker)
            {
                while (!_signal) monitor.wait(_locker);
            }
        }

        void set()
        {
            lock (_locker) { _signal = true; monitor.pulseall(_locker); }
        }

        void reset() { lock (_locker) _signal = false; }

在这里使用pulseall，是因为可能有很多阻塞的线程。

如果在waitone方法中增加_signal=false就可以简单的模拟autoresetevent.例如：

void waitone()
        {
            lock (_locker)
            {
                while (!_signal) monitor.wait(_locker);
                _signal = false; //实现自动关闭功|能
            }
        }

然后在set方法中，将pulseall修改为pulse

lock(_locker) {_signal = true; monitor.pulse(_locker);}

如果使用的是int类型的_signal 标志，那么我们可以得到一个最基本的semaphore.

waiting queues and pulseall

当多余一个线程在同一个对象上面等待的时候，一个 “等待队列(waiting queue)” 就形成了。

每一次调用pulse都会释放在”等待队列”头部的一个线程。下面的图形象的展示了这一点：

 

线程调用monitor.enter 进入readyqueue. 等待获取锁，成功获取锁后，如果正常的执行，那么之后会调用monitor.exit退出,

否则如果获取了锁之后发现需要等待其他的线程或者是其他阻塞条件，那么调用wait方法，就进入了等待队列，

当等待的线程完成并调用pulse后，处在waitingqueue头部的线程就被 pulse了，等待cpu调度 。之后再次进入ready queue，重新获取锁。

countdown

借助wait和pulse，我们可以实现countdownevent的主要功能。例如：

class countdown
    {
        object _locker = new object();
        int _value; //使用_value来计数

        public countdown() { }
        public countdown(int initialcount) { _value = initialcount; }

        public void singnal() { addcount(-1); } //将计数减一

        public void addcount(int amount)
        {
            lock (_locker)
            {
                _value += amount; //将计数增加或减少
                if (_value <= 0) monitor.pulseall(_locker);//如果value<=0,说明所有等待的任务都完成了。
            }
        }

        public void wait()
        {
            lock (_locker)
            {
                //只要计数 > 0 就等待。
                while (_value > 0)
                {
                    monitor.wait(_locker);
                }
            }
        }
}

这和我们上次的代码几乎一致，只是这次我们的阻塞条件基于一个整型_value标志。