211. Orchard学习二 2、ManualResetEvent 与 AutoResetEvent-白红宇

211. Orchard学习二 2、ManualResetEvent 与 AutoResetEvent

阅读量：5077 次

发布时间：2019-06-12

本文共 7830 字，大约阅读时间需要 26 分钟。

一、Orchard里异步请求处理线程队列的控制

Orchard的Orchard.WarmupStarter模块，为HttpApplication.BeginRequest时间附加了一个异步处理事件：BeginBeginRequest。

/// 
/// 启动 System.Web.HttpApplication.BeginRequest 的异步处理的 System.Web.BeginEventHandler
/// System.Web.HttpApplication.BeginRequest 在 ASP.NET 响应请求时作为 HTTP 执行管线链中的第一个事件发生。
/// 
private IAsyncResult BeginBeginRequest(object sender, EventArgs e, AsyncCallback cb, object extradata)
{
    // host is available, process every requests, or file is processed
    if (!InWarmup() || WarmupUtility.DoBeginRequest(_context))
    {
        /***
         *  !InWarmup()  不在预热中
         *  WarmupUtility.DoBeginRequest(_context) 找到了与请求URL匹配的静态文件资源
         */
        var asyncResult = new DoneAsyncResult(extradata);
        cb(asyncResult);
        return asyncResult;
    }
    else
    {
        // this is the "on hold" execution path
        var asyncResult = new WarmupAsyncResult(cb, extradata);
        Await(asyncResult.Completed);
        return asyncResult;
    }
}

在请求开始时，检查系统状态，“不在预热中”或者找到了与请求的URL匹配的静态文件资源，则构造一个 DoneAsncResult类型实例，执行并返回结果状态。如果正在预热，或没有匹配的静态文件资源，将请求加入一个待执行队列，直到预热完成发出信号后再执行（这个见Orchard.WarmupStarter.Starter.LaunchStartupThread()）。

我们再来看 DoneAsyncResult和WarmupAsyncResult

/// 
/// AsyncResult for "on hold" request (resumes when "Completed()" is called)
/// 
private class WarmupAsyncResult : IAsyncResult
{
    /****************
    // 通知一个或多个正在等待的线程已发生事件，处理器类型。      “等待线程 事件通知 处理器”.
    // AutoResetEvent 继承自 ,EventWaitHandle:WaitHandle ， 表示一个线程同步事件。
    // EventWaitHandle 主要操作方法： Set() , Reset()。
    // WaitHandle 封装等待对共享资源的独占访问的操作系统特定的对象

    // 初始化一个  “等待线程 事件通知 处理器” 。
    // 参数 initialState ，初始状态是否为 终止：
    //     true   终止  ，即目前已无事件发生，无需等待，线程继续运行
    //     false  非终止，即目前有事件发生，需等待，线程暂停运行
    ****************/
    private readonly EventWaitHandle _eventWaitHandle = new AutoResetEvent(false/*initialState*/);
 
    //...省略若干代码
}
 
/// 
/// 已 “执行完成 or 正在处理” 的异步操作状态
/// Async result for "ok to process now" requests
/// 
private class DoneAsyncResult : IAsyncResult
{
    /****************
    // 通知一个或多个正在等待的线程已发生事件，处理器类型。      “等待线程 事件通知 处理器”.
    // ManualResetEvent 继承自 ,EventWaitHandle:WaitHandle ， 表示一个线程同步事件。
    // EventWaitHandle 主要操作方法： Set() , Reset()。
    // WaitHandle 封装等待对共享资源的独占访问的操作系统特定的对象

    // 初始化一个  “等待线程 事件通知 处理器” 。
    // 参数 initialState ，初始状态是否为 终止：
    //     true   终止  ，即目前已无事件发生，无需等待，线程继续运行
    //     false  非终止，即目前有事件发生，需等待，线程暂停运行
    ****************/
    private static readonly WaitHandle _waitHandle = new ManualResetEvent(true/*initialState*/);
 
    //...省略若干代码
}

他们分别实例化了事件通知处理器。AutoResetEvent 和 ManualResetEvent 都继承自 EventWaitHandle,WaitHandle ，表示一个线程同步事件通知器。通俗的讲，就是程序中需要跨多个线程处理协调事件时，一个用来通知协调事件处理状态的处理器。

EventWaitHandle 主要操作方法：

Set() ：将事件状态设置为终止状态，即目前已无事件发生，无需等待，其他等待中的线程继续运行；

Reset() ：将事件状态设置为非终止状态，即目前有事件发生，需等待，其他线程暂停运行；

WaitOne()：阻塞当前线程，直到 _resetEventHandler 收到新的事件信号（即 set or reset）；

AutoResetEvent 和 ManualResetEvent初始化时，参数 initialState ，初始状态是否为终止。其表意如下：

true 终止，即目前已无事件发生，无需等待，线程继续运行,

false 非终止，即目前有事件发生，需等待，线程暂停运行

二、AutoResetEvent 与 ManualResetEvent

看起来 AutoResetEvent 和 ManualResetEvent 很像，我们通过一个demo来看看他们的区别

Class Program 与 CLaunchStartupThread

class Program
{
    static void Main(string[] args)
    {
        Common.ConsoleWriteLine("----------------------", false);
        Common.ConsoleWriteLine(" S 暂停      R 继续   ", false);
 
        var resetEventHandler = new ResetEventHandle
        (new ManualResetEvent(true));
        //var resetEventHandler = new ResetEventHandle
        (new AutoResetEvent(true));
        Common.ConsoleWriteLine(" Type: " + resetEventHandler.CurTypeName, false);
        Common.ConsoleWriteLine(" MainThread: ");
        Common.ConsoleWriteLine("\r\n", false);
        //创建线程
        Common.CreateThreads(resetEventHandler.Run, 3);
 
        while (true)
        {
            string input = Console.ReadLine();
            if (input.Trim().ToLower() == "s")
            {
                Common.ConsoleWriteLine("线程 暂停 运行.");
                resetEventHandler.Reset();
            }
            else if (input.Trim().ToLower() == "r")
            {
                Common.ConsoleWriteLine("线程 继续 运行.");
                resetEventHandler.Set();
            }
        }
 
    }
}
class Common
{
    public static void CreateThreads(Action runFunc, int tCount = 2)
    {
        var i = 0;
        while (i < tCount)
        {
            var t = new Thread(new ThreadStart(runFunc));
            t.Start();
            i++;
        }
    }
    public static void ConsoleWriteLine(string msg, bool withThreadSign = true, bool withDateTimeSign = false)
    {
        Console.WriteLine(
            msg +
            (withThreadSign ? (" [ThreadId: " + Thread.CurrentThread.ManagedThreadId.ToString() + " ]") : "") +
            (withDateTimeSign ? ("[" + System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "]") : "")
            );
    }
}

ResetEventHandle.cs

class ResetEventHandle
         where T : EventWaitHandle
{
    /// test
    /// 通知一个或多个正在等待的线程已发生事件，处理器类型。      “等待线程 事件通知 处理器”.
    /// ManualResetEvent 继承自 ,EventWaitHandle:WaitHandle ， 表示一个线程同步事件。
    /// EventWaitHandle 主要操作方法： Set() , Reset()。
    /// WaitHandle 封装等待对共享资源的独占访问的操作系统特定的对象
    /// 
    private T _resetEventHandler;
 
    public ResetEventHandle(T resetEventHandler)
    {
        // 初始化一个  “等待线程 事件通知 处理器” 。
        // 参数 initialState ，初始状态是否为 终止：
        //     true   终止  ，即目前已无事件发生，无需等待程暂，线程继续运行
        //     false  非终止，即目前有事件发生，需等待，线停运行
        // this._mre = new ManualResetEvent(true);
        this._resetEventHandler = resetEventHandler;
    }
 
    public string CurTypeName { get { return _resetEventHandler.GetType().Name; } }
    /// 
    /// 将事件状态设置为终止状态， 即目前已无事件发生，无需等待，其他等待中的线程继续运行
    /// 
    public void Set() { this._resetEventHandler.Set(); }
 
    /// 
    /// 将事件状态设置为非终止状态，即目前有事件发生，需等待，其他线程暂停运行
    /// 
    public void Reset() { this._resetEventHandler.Reset(); }
 
    public void Run()
    {
        string strThreadID = string.Empty;
        try
        {
            while (true)
            {
                // 阻塞当前线程 ，直到 _resetEventHandler 收到新的事件信号（即 set or reset）
                this._resetEventHandler.WaitOne();
 
                strThreadID = Thread.CurrentThread.ManagedThreadId.ToString();
                Common.ConsoleWriteLine("线程 (" + strThreadID + ") 正在运行.");
 
                Thread.Sleep(5000);
            }
        }
        catch (Exception ex)
        {
            Common.ConsoleWriteLine("线程 (" + strThreadID + ") 异常！错误：" + ex.Message.ToString());
        }
    }
}

在Program.Main()中，如果调用AutoResetEvent类型，我们每次输入r，创建的三个线程继续运行，但一次只运行一个线程，其他被阻塞的线程则继续等待通知信号：

如果调用ManualResetEvent类型，我们每次输入r，创建的三个线程继续运行，每次所有创建后被阻塞的线程都会运行起来：

三、生活中的例子：
参考文档中，所列公路收费站的例子并不恰当。我们参考一下地铁闸机：

四、一点总结：

- ManualResetEvent 和 AutoResetEvent都可以继续运行或阻塞线程，并且都是一次性阻塞所有影响到的线程；
- ManualResetEvent 是一次继续运行一批线程；
- AutoResetEvent 是一次继续运行一个线程，其他影响到的线程继续等待新的事件通知信号；
- AutoResetEvent.Set() = ManualResetEvent.Set() + ManualResetEvent.Reset();
- 如果共享资源仅允许单线程使用的情况下，应选择AutoResetEvent；如果共享资源允许多个线程同时使用，则可以选择ManualResetEvent；
- 言外之意，只有一个待处理线程时，ManualResetEvent 和 AutoResetEvent效果是一致的。