C#简单理解 Monitor.Wait 与 Monitor.Pulse

一. 关于 Monitor 控制下线程的三个状态

1. 拥有锁的线程：先行得到锁的线程，得到锁之后，其他线程将进入就绪队列进行等待锁的释放

2. 就绪队列中的线程：等待获取锁

3. 等待队列中的线程：等待显式地被移入就绪队列

二. 方法说明和原理

1.  Monitor.Wait 方法

有两个比较常用的方法重载：

• Monitor.Wait(Object)

  Object：等待的锁的对象

  功能：释放当前线程所占用的对象锁，并且阻塞当前的线程直到它再次拥有这个锁。

             Releases the lock on an object and blocks the current thread until it reacquires the lock.

• Monitor.Wait(Object，Int32)

  - Object：等待的锁的对象

  - Int32：线程再次进入就绪队列的等待时长，单位毫秒

  功能：释放当前线程所占用的对象锁，并且阻塞当前的线程直到它再次拥有这个锁。如果指定的时长过去，线程将由等待队列转移到就绪队列。

            Releases the lock on an object and blocks the current thread until it reacquires the lock. If the specified time-out interval elapses, the thread enters the ready queue.

2. Monitor.Wait 方法的主要执行步骤

• 阻塞当前的线程

• 将这个线程移动到等待队列中

• 释放当前的同步锁

3. Monitor.Pulse (Object)

功能：通知一个等待队列中的线程，当前锁的状态被改变。（说白了就是有一个线程可以从等待队列中被移入就绪队列）

Notifies a thread in the waiting queue of a change in the locked object's state.

4. Monitor.PulseAll(Object)

功能：通知所有的等待队列中的线程，当前锁的状态改变。（说白了就是所有的线程可以从等待队列中被移入就绪队列）

Notifies all waiting threads in the waiting queue of a change in the locked object's state.

5. Monitor.Pulse 和 Monitor.PulseAll 的使用写法：

只能由当前获得锁的线程，调用 Monitor.Pulse 和 Monitor.PluseAll 后，使等待队列中的线程转义到就绪队列。

代码一般如下：

lock(obj)
{
    Monitor.Pulse(obj);
}


lock(obj)
{
    Monitor.PulseAll(obj);
}

三. 模拟情形分析

情形一：

1. 假设有5个同时开始的线程，分别是 t1、t2、t3、t4 和 t5，它们将会同时进入一个 lock 区域，如下：

lock(obj)
{
    Monitor.Wait(obj);
}

 2. 由于线程 t1 被第一个处理，进而进入了 lock，它获得锁，此时所有线程的状态：

拥有锁的线程	t1
就绪队列	t2、t3、t4、t5
等待队列

3. 假设线程 t1 运行到了 Monitor.Wait，它将会被从拥有线程锁状态移动到等待队列状态中，于此同时将会释放其拥有的锁，而其它在就绪队列中的线程将有机会获得这个锁：

拥有锁的线程
就绪队列	t2、t3、t4、t5
等待队列	t1

4. 此时假设线程 t2 获取了 t1 释放的锁，它将进入 lock 区域中，此时所有的线程状态如下：

拥有锁的线程	t2
就绪队列	t3、t4、t5
等待队列	t1

5. 接着 t2 在 lock 区域中也会执行 Monitor.Wait ，之后 t2 也会像 t1 一样进入等待队列，重复 1、2 步骤，直至所有的线程 t1、t2、t3、t4、t5 都进入等待队列，如下图：

拥有锁的线程
就绪队列
等待队列	t1、t2、t3、t4、t5

情形二：

如何将上面等待队列中的某一个线程重新变为就绪状态，从而可以再次拿到锁呢？

答：我们可以使用 Monitor.Pulse 来让 t1 线程从等待队列中转移到就绪队列中。

★★ 这里有一个需要注意的地方，就是 " 等待队列 " 是一个队列，满足  " 先进先出 "，所以第一个线程 t1 会被优先释放到就绪队列中。如图是在情形一所有线程都在等待队列中，优先释放哪一个到就绪队列的截图：

1. 我们在情形一第5点的状态下执行 Monitor.Pulse，此时所有的线程的状态如下：

拥有锁的线程
就绪队列	t1
等待队列	t2、t3、t4、t5

2. 然后，线程 t1 在就绪队列中就会拿到锁，从 Monitor.Wait 的下一句程序开始执行：

拥有锁的线程	t1
就绪队列
等待队列	t2、t3、t4、t5

3. 最后，t1 线程在执行完 lock 区域的剩余部分的代码之后就会退出，同时释放线程锁。于此同时，其它的线程依然被卡在等待队列中等待，如下：

拥有锁的线程
就绪队列
等待队列	t2、t3、t4、t5

 4. 对于 Monitor.PulseAll 将会把所有的等待状态的线程都移到就绪状态的队列中，从而有机会获得锁进行执行。从第3步接着执行 Monitor.PulseAll 之后，所有的线程状态如下：

拥有锁的线程
就绪队列	t2、t3、t4、t5
等待队列

四. 运用

我们来利用 Monitor.Wait 和 Monitor.Pulse 来实现一下 AutoResetEvent 。

代码部分：

/// 

/// 自己的写的AutoResetEvent
/// 
public class AutoResetEventEx
{
    /// 

    /// 内部的设置状态 
    /// true  不等待信号
    /// false 等待信号
    /// 
    private bool _initialState = false;


    /// 

    /// 内部锁
    /// 
    private object _objLock = new object();


    /// 

    /// 构造函数
    /// 
    /// 内部的设置状态
    public AutoResetEventEx(bool initialState)
    {
        this._initialState = initialState;
    }


    /// 

    /// 等待一个信号
    /// 
    public void WaitOne()
    {
        if(!this._initialState)
        {
            lock(this._objLock)
            {
                Monitor.Wait(this._objLock);
            }
        }
    }


    /// 

    /// 发送一个信号
    /// 
    public void Set()
    {
        if (!this._initialState)
        {
            this._initialState = true;


            lock (this._objLock)
            {
                Monitor.PulseAll(this._objLock);
            }
        }
    }
}

上端调用部分：

AutoResetEventEx autoResetEventEx = new AutoResetEventEx(true);


Thread th = new Thread(() =>
    {
        Thread.Sleep(10 * 1000);


        Console.WriteLine("- Set -");
        autoResetEventEx.Set();
    });
th.IsBackground = true;
th.Start();


Console.WriteLine("- WaitOne -");
autoResetEventEx.WaitOne();


Console.WriteLine("- Exit -");
Console.ReadKey();

运行结果：

五. 性能对比

最后，对比一下 C# 框架的 AutoResetEvent 和手动实现的 AutoResetEventEx：

• AutoResetEventEx 是 Monitor 实现的，Monitor 采用的是混合锁（用户模式 + 内核模式），不是采用 Win32 API

• AutoResetEvent 采用的是 Win32 的 API 的 WaitHandle 实现的，所以性能相对比较低（？）