一. 关于 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 。
代码部分：
/// <summary>
/// 自己的写的AutoResetEvent
/// </summary>
public class AutoResetEventEx
{
/// <summary>
/// 内部的设置状态
/// true 不等待信号
/// false 等待信号
/// </summary>
private bool _initialState = false;
/// <summary>
/// 内部锁
/// </summary>
private object _objLock = new object();
/// <summary>
/// 构造函数
/// </summary>
/// <param name="initialState">内部的设置状态</param>
public AutoResetEventEx(bool initialState)
{
this._initialState = initialState;
}
/// <summary>
/// 等待一个信号
/// </summary>
public void WaitOne()
{
if(!this._initialState)
{
lock(this._objLock)
{
Monitor.Wait(this._objLock);
}
}
}
/// <summary>
/// 发送一个信号
/// </summary>
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文章来源：https://www.toymoban.com/news/detail-409442.html
AutoResetEvent 采用的是 Win32 的 API 的 WaitHandle 实现的，所以性能相对比较低（？）文章来源地址https://www.toymoban.com/news/detail-409442.html
到了这里，关于C#简单理解 Monitor.Wait 与 Monitor.Pulse的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
