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 会被优先释放到就绪队列中。如图是在情形一所有线程都在等待队列中,优先释放哪一个到就绪队列的截图:

C#简单理解 Monitor.Wait 与 Monitor.Pulse_第1张图片

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();

3fb832244ba8ab8ef5d0dfe4b835f61e.png

运行结果:

084fe92a5af723d6931519b83e70a30a.png

五. 性能对比

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

  • AutoResetEventEx 是 Monitor 实现的,Monitor 采用的是混合锁(用户模式 + 内核模式),不是采用 Win32 API

  • AutoResetEvent 采用的是 Win32 的 API 的 WaitHandle 实现的,所以性能相对比较低(?)

你可能感兴趣的:(队列,c#,java,多线程,并发编程)