简单介绍

如果预计操作的等待的时间非常短，可以考虑使用轻量级的手动重置事件，ManualResetEventSlim。它可以发出信号和等待事件。从名称和使用方式上看，它主要是提供以人为本的操作方式，在基于人对程序运行过程非常了解的情况下，由人控制整个同步的过程。

ManualResetEventSlim 提供了3个常用的方法和3个只读的属性。

构造函数：

  • ManualResetEventSlim()：使用无信号初始状态初始化 ManualResetEventSlim 类的新实例。
  • ManualResetEventSlim(Boolean)：使用一个指示是否将初始状态设置为有信号的布尔值初始化 
    ManualResetEventSlim 类的新实例。
  • ManualResetEventSlim(Boolean, Int32)：使用一个指示是否将初始状态设置为有信号和指定自旋计数的布尔值初始化 ManualResetEventSlim 类的新实例。

方法：

  • Reset：将事件置为false (取消设置/取消信号)
  • Set：将事件置为true(设置/发出信号)，如果有任务在等待，这时它会得到这个信号并解除阻塞。
  • Wait：阻塞当前任务或线程，直到另外的线程发出信号。

属性：

  • IsSet：一个bool值，表明事件是否被设置。
  • SpinCount：进入内核等待前要执行自旋的次数。
  • WaitHandle：提供了操作系统对象WaitHandle的访问。通过这个对象可以等待对共享资源的排他访问。

程序示例：在这个例子中使用了ManualResetEventSlim，它使得Task1,2,3变成了顺序运行。

  1. using System;
  2. using System.Text;
  3. using System.Threading;
  4. using System.Threading.Tasks;
  6. namespace Sample5_7_manualreseteventslim
  7. {
  8.     class Program
  9.     {
  10.         private static int _TaskNum = 3;
  11.         private static Task[] _Tasks;
  12.         private static StringBuilder _StrBlder;
  13.         private const int RUN_LOOP = 10;
  15.         private static ManualResetEventSlim m_Worker2Event;
  16.         private static ManualResetEventSlim m_Worker3Event;
  18.         private static void Work1(int TaskID)
  19.         {
  20.             int i = 0;
  21.             string log = "";
  23.             while (i < RUN_LOOP)
  24.             {
  25.                 log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
  26.                                   DateTime.Now.TimeOfDay, TaskID, i);
  27.                 i++;
  28.                 try
  29.                 {
  30.                     _StrBlder.Append(log);
  31.                 }
  32.                 finally
  33.                 {
  34.                     m_Worker2Event.Set();
  35.                 }
  36.             }
  37.         }
  39.         private static void Work2(int TaskID)
  40.         {
  41.             int i = 0;
  42.             string log = "";
  44.             m_Worker2Event.Wait();
  46.             while ((i < RUN_LOOP) && (m_Worker2Event.IsSet))
  47.             {
  48.                 log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
  49.                                   DateTime.Now.TimeOfDay, TaskID, i);
  50.                 i++;
  51.                 try
  52.                 {
  53.                     _StrBlder.Append(log);
  54.                 }
  55.                 finally
  56.                 {
  57.                     m_Worker3Event.Set();
  58.                 }
  59.             }
  60.         }
  62.         private static void Work3(int TaskID)
  63.         {
  64.             int i = 0;
  65.             string log = "";
  67.             m_Worker3Event.Wait();
  69.             while ((i < RUN_LOOP) && (m_Worker3Event.IsSet))
  70.             {
  71.                 log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
  72.                                   DateTime.Now.TimeOfDay, TaskID, i);
  73.                 i++;
  74.                 try
  75.                 {
  76.                     _StrBlder.Append(log);
  77.                 }
  78.                 finally
  79.                 {
  80.                 }
  81.             }
  82.         }
  84.         static void Main(string[] args)
  85.         {
  86.             _Tasks = new Task[_TaskNum];
  87.             _StrBlder = new StringBuilder();
  88.             m_Worker2Event = new ManualResetEventSlim(false, 100);
  89.             m_Worker3Event = new ManualResetEventSlim(false, 100);
  91.             _Tasks[0] = Task.Factory.StartNew((num) =>
  92.             {
  93.                 var taskid = (int)num;
  94.                 Work1(taskid);
  95.             }, 0);
  97.             _Tasks[1] = Task.Factory.StartNew((num) =>
  98.             {
  99.                 var taskid = (int)num;
  100.                 Work2(taskid);
  101.             }, 1);
  103.             _Tasks[2] = Task.Factory.StartNew((num) =>
  104.             {
  105.                 var taskid = (int)num;
  106.                 Work3(taskid);
  107.             }, 2);
  109.             var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
  110.             {
  111.                 Task.WaitAll(_Tasks);
  112.                 Console.WriteLine("==========================================================");
  113.                 Console.WriteLine("All Phase is completed");
  114.                 Console.WriteLine("==========================================================");
  115.                 Console.WriteLine(_StrBlder);
  116.             });
  118.             try
  119.             {
  120.                 finalTask.Wait();
  121.             }
  122.             catch (AggregateException aex)
  123.             {
  124.                 Console.WriteLine("Task failed And Canceled" + aex.ToString());
  125.             }
  126.             finally
  127.             {
  128.                 m_Worker2Event.Dispose();
  129.                 m_Worker3Event.Dispose();
  130.             }
  131.             Console.ReadLine();
  132.         }
  134.     }
  135. }

使用超时和取消

超时机制对于任务的同步是非常必要的，这里也提供了用户设置超时的方法。 
ManualResetEventSilm.Wait(int TIME_OUT);

程序示例：在这个例子中任务1会等待5秒后在设置Event，但任务2，3的超时时间为2秒。

  1. using System;
  2. using System.Text;
  3. using System.Threading;
  4. using System.Threading.Tasks;
  6. namespace Sample5_7_manualreseteventslim
  7. {
  8.     class Program
  9.     {
  10.         private static int _TaskNum = 3;
  11.         private static Task[] _Tasks;
  12.         private static StringBuilder _StrBlder;
  13.         private const int RUN_LOOP = 10;
  15.         private static ManualResetEventSlim m_Worker2Event;
  16.         private static ManualResetEventSlim m_Worker3Event;
  18.         private static void Work1(int TaskID)
  19.         {
  20.             int i = 0;
  21.             string log = "";
  23.             while (i < RUN_LOOP)
  24.             {
  25.                 log = String.Format("Time: {0}  Task : #{1}  Value: {2}  =====\n",
  26.                                   DateTime.Now.TimeOfDay, TaskID, i);
  27.                 i++;
  28.                 try
  29.                 {
  30.                     _StrBlder.Append(log);
  31.                 }
  32.                 finally
  33.                 {
  34.                     System.Threading.Thread.Sleep(5000);
  35.                     m_Worker2Event.Set();
  36.                 }
  37.             }
  38.         }
  40.         private static void Work2(int TaskID)
  41.         {
  42.             int i = 0;
  43.             string log = "";
  45.             if (!m_Worker2Event.Wait(2000))
  46.             {
  47.                 Console.WriteLine("Task 2 wait for event TIME OUT!!");
  48.                 return;
  49.             }
  51.             while ((i < RUN_LOOP) && (m_Worker2Event.IsSet))
  52.             {
  53.                 log = String.Format("Time: {0}  Task : #{1}  Value: {2}  *****\n",
  54.                                   DateTime.Now.TimeOfDay, TaskID, i);
  55.                 i++;
  56.                 try
  57.                 {
  58.                     _StrBlder.Append(log);
  59.                 }
  60.                 finally
  61.                 {
  62.                     m_Worker3Event.Set();
  63.                 }
  64.             }
  65.         }
  67.         private static void Work3(int TaskID)
  68.         {
  69.             int i = 0;
  70.             string log = "";
  72.             if (!m_Worker3Event.Wait(2000))
  73.             {
  74.                 Console.WriteLine("Task 3 wait for event TIME OUT!!");
  75.                 return;
  76.             }
  78.             while ((i < RUN_LOOP) && (m_Worker3Event.IsSet))
  79.             {
  80.                 log = String.Format("Time: {0}  Task : #{1}  Value: {2}  ~~~~~\n",
  81.                                   DateTime.Now.TimeOfDay, TaskID, i);
  82.                 i++;
  83.                 try
  84.                 {
  85.                     _StrBlder.Append(log);
  86.                 }
  87.                 finally
  88.                 {
  89.                 }
  90.             }
  91.         }
  93.         static void Main(string[] args)
  94.         {
  95.             _Tasks = new Task[_TaskNum];
  96.             _StrBlder = new StringBuilder();
  97.             m_Worker2Event = new ManualResetEventSlim(false, 100);
  98.             m_Worker3Event = new ManualResetEventSlim(false, 100);
  100.             _Tasks[0] = Task.Factory.StartNew((num) =>
  101.             {
  102.                 var taskid = (int)num;
  103.                 Work1(taskid);
  104.             }, 0);
  106.             _Tasks[1] = Task.Factory.StartNew((num) =>
  107.             {
  108.                 var taskid = (int)num;
  109.                 Work2(taskid);
  110.             }, 1);
  112.             _Tasks[2] = Task.Factory.StartNew((num) =>
  113.             {
  114.                 var taskid = (int)num;
  115.                 Work3(taskid);
  116.             }, 2);
  118.             var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
  119.             {
  120.                 Task.WaitAll(_Tasks);
  121.                 Console.WriteLine("==========================================================");
  122.                 Console.WriteLine("All Phase is completed");
  123.                 Console.WriteLine("==========================================================");
  124.                 Console.WriteLine(_StrBlder);
  125.             });
  127.             try
  128.             {
  129.                 finalTask.Wait();
  130.             }
  131.             catch (AggregateException aex)
  132.             {
  133.                 Console.WriteLine("Task failed And Canceled" + aex.ToString());
  134.             }
  135.             finally
  136.             {
  137.                 m_Worker2Event.Dispose();
  138.                 m_Worker3Event.Dispose();
  139.             }
  140.             Console.ReadLine();
  141.         }
  143.     }
  144. }

可以注意到其实Task 1只是阻塞了Task2，但Task3也受到了超时的影响。超时机制在系统中的传播会对整个程序造成一定的影响。

好的方面：帮助系统所有模块了解到系统中出现了某些异常，要采取措施了。 
坏的方面：有些模块对于其他模块的超时并没有相应的准备，直接导致一连串的异常的反应，系统崩溃。

跨进程或AppDomain的同步

如果需要实现跨进程的同步，这时可以使用ManualResetEvent。ManualResetEvent和ManualResetEventSlim有一定的区别，比如它没有IsSet属性。

方法：

  • Reset：将事件置为false (取消设置/取消信号)
  • Set：将事件置为true(设置/发出信号)，如果有任务在等待，这时它会得到这个信号并解除阻塞。
  • WaitOne：阻塞当前任务或线程，直到另外的线程发出信号。

ManualResetEvent的使用方式和ManualResetEventSlim还是基本一致的。

C# 并行编程 之 轻量级手动重置事件的使用的更多相关文章

  1. C#线程同步手动重置事件——ManualResetEvent

    和AutoResetEvent类的区别是,Manual一旦set后不会自动reset,会放行所有waitone的线程,而autoresetevent每一次set之后只会放行一个waitone的线程,然 ...

  2. C#并行编程-线程同步原语

    菜鸟学习并行编程,参考<C#并行编程高级教程.PDF>,如有错误,欢迎指正. 目录 C#并行编程-相关概念 C#并行编程-Parallel C#并行编程-Task C#并行编程-并发集合 ...

  3. C#并行编程 (Barrier,CountdownEvent,ManualResetEventSlim,SemaphoreSlim,SpinLock,SpinWait )

    背景 有时候必须访问变量.实例.方法.属性或者结构体,而这些并没有准备好用于并发访问,或者有时候需要执行部分代码,而这些代码必须单独运行,这是不得不通过将任务分解的方式让它们独立运行. 当任务和线程要 ...

  4. C#并行编程（6）：线程同步面面观

    理解线程同步 线程的数据访问 在并行(多线程)环境中,不可避免地会存在多个线程同时访问某个数据的情况.多个线程对共享数据的访问有下面3种情形: 多个线程同时读取数据: 单个线程更新数据,此时其他线程读 ...

  5. C#中的多线程 - 并行编程 z

    原文:http://www.albahari.com/threading/part5.aspx 专题:C#中的多线程 1并行编程Permalink 在这一部分,我们讨论 Framework 4.0 加 ...

  6. 【温故而知新-万花筒】C# 异步编程 逆变 协变 委托 事件 事件参数 迭代 线程、多线程、线程池、后台线程

    额基本脱离了2.0 3.5的时代了.在.net 4.0+ 时代.一切都是辣么简单! 参考文档: http://www.cnblogs.com/linzheng/archive/2012/04/11/2 ...

  7. 6.跑步者--并行编程框架 ForkJoin

    本文如果您已经了解一般并行编程知识.了解Java concurrent部分如ExecutorService等相关内容. 虽说是Java的ForkJoin并行框架.但不要太在意Java,当中的思想在其他 ...

  8. Python3 系列之 并行编程

    进程和线程 进程是程序运行的实例.一个进程里面可以包含多个线程,因此同一进程下的多个线程之间可以共享线程内的所有资源,它是操作系统动态运行的基本单元:每一个线程是进程下的一个实例,可以动态调度和独立运 ...

  9. Objective-C编程 — 并行编程

    多线程 线程的基本概念 线程 (thread)是进程(process)A 内假想的持有 CPU 使用权的执行单位.一般情况下,一个进程 只有一个线程,但也可以创建多个线程并在进程中并行执行.应用在执行 ...

随机推荐

  1. ASP.NET MVC WEBAPI第一次接触

    asp.net 的MVC4 WEBAPI的出现已经有段时间了.最近因为做自己的一些小玩儿,要做一个API,正好可以学习一下这个WEBAPI. WEBAPI项目的创建我就不啰嗦,先来看看webapi的路 ...

  2. Vagrant的一个BUG - 不支持'change_host_name'

    ==> master: Setting hostname... Vagrant attempted to execute the capability 'change_host_name' on ...

  3. Nodejs学习（一）－Nodejs和express的安装和配置

    声明我的操作系统是ubuntu环境,直接下载了tar文件进行解压安装,步骤如下 1.nodejs官网下载node-v4.6.0-linux-x86.tar.xz文件. youyuan1980@youy ...

  4. webForm中的验证控件

    1.非空验证控件:RequireFieldValidator  :2.数据比较验证:CompareValidator :3.数据范围验证:RangeValidator :4.正则表达式验证:Regul ...

  5. 软件工程练习， 模块化，单元测试，回归测试，TDD

    这是<构建之法>实战教学的一部分.适合作为同学们的第二个程序作业. 第一个程序作业: 请看 “概论” 一章的练习,或者老师的题目,例如这个. 作业要求: 软件工程的作业越来越有意思了, 我 ...

  6. python基础知识9——模块2——常见内置模块

    内置模块 内置模块是Python自带的功能,在使用内置模块相应的功能时,需要[先导入]再[使用] 1.sys 用于提供对Python解释器相关的操作: sys.argv 命令行参数List,第一个元素 ...

  7. Spring AOP /代理模式/事务管理/读写分离/多数据源管理

    参考文章: http://www.cnblogs.com/MOBIN/p/5597215.html http://www.cnblogs.com/fenglie/articles/4097759.ht ...

  8. 在sql server中利用with as实现递归功能

    在sqlserver2005之前,要实现递归功能比较麻烦,比如可能会要用到临时表与while语句来循环.自sqlserver2005之后,新增了with as功能语法,即 公用表达式(CTE),让递归 ...

  9. Badboy使用数据源Excel进行脚本参数化

    1.首先新建一个Excel,这里示例我写得非常简单,由两由数据组成,第一行为表头.见下图: 2.录制脚本,见上一篇,录制一个非常简单的搜狗查询 3.添加数据源,在Tools面板中找到Data Sour ...

  10. 学习C：打印输入中单词长度的水平方向直方图

    #include <stdio.h>#define IN 1#define OUT 0#define MAXWL 16 main() { /*打印输入单词长度的水平直方图*/ int c, ...