C#多线程：深入了解线程同步lock,Monitor,Mutex,同步事件和等待句柄（中）

本篇继续介绍WaitHandler类及其子类 Mutex，ManualResetEvent，AutoResetEvent的用法。.NET中线程同步的方式多的让人看了眼花缭乱，究竟该怎么去理解呢？其实，我们抛开.NET环境看线程同步，无非是执行两种操作：一是互斥/加锁，目的是保证临界区代码操作的“原子性”；另一种是信号灯操作，目的是保证多个线程按照一定顺序执行，如生产者线程要先于消费者线程执行。.NET中线程同步的类无非是对这两种方式的封装，目的归根结底都可以归结为实现互斥/ 加锁或者是信号灯这两种方式，只是它们的适用场合有所不。下面我们根据类的层次结构了解WaitHandler及其子类。 
      1.WaitHandler

WaitHandle是Mutex，Semaphore，EventWaitHandler，AutoResetEvent，ManualResetEvent共同的祖先，它封装Win32同步句柄内核对象，也就是说是这些内核对象的托管版本。

线程可以通过调用WaitHandler实例的方法WaitOne在单个等待句柄上阻止。此外，WaitHandler类重载了静态方法，以等待所有指定的等待句柄都已收集到信号WaitAll，或者等待某一指定的等待句柄收集到信号WaitAny。这些方法都提供了放弃等待的超时间隔、在进入等待之前退出同步上下文的机会，并允许其它线程使用同步上下文。WaitHandler是C#中的抽象类，不能实例化。

2.EventWaitHandler vs. ManualResetEvent vs. AutoResetEvent（同步事件）

我们先看看两个子类ManualResetEvent和AutoResetEvent在.NET Framework中的实现：

C#代码  

  1. //.NET Framework中ManualResetEvent类的实现
  2. [ComVisible(true), HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
  3. public sealed class ManualResetEvent : EventWaitHandle
  4. {
  5. // Methods
  6. public ManualResetEvent(bool initialState) : base(initialState, EventResetMode.ManualReset)
  7. {
  8. }
  9. }
  10. //.NET Framework中AutoResetEvent类的实现
  11. [ComVisible(true), HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
  12. public sealed class AutoResetEvent : EventWaitHandle
  13. {
  14. // Methods
  15. public AutoResetEvent(bool initialState)
  16. : base(initialState, EventResetMode.AutoReset)
  17. {
  18. }
  19. }

原来ManualResetEvent和AutoResetEvent都继承自EventWaitHandler，它们的唯一区别就在于父类 EventWaitHandler的构造函数参数EventResetMode不同，这样我们只要弄清了参数EventResetMode值不同时，EventWaitHandler类控制线程同步的行为有什么不同，两个子类也就清楚了。为了便于描述，我们不去介绍父类的两种模式，而直接介绍子类。

ManualResetEvent和AutoResetEvent的共同点： 
      1）Set方法将事件状态设置为终止状态，允许一个或多个等待线程继续；Reset方法将事件状态设置为非终止状态，导致线程阻止；WaitOne阻止当前线程，直到当前线程的WaitHandler收到事件信号。 
      2）可以通过构造函数的参数值来决定其初始状态，若为true则事件为终止状态从而使线程为非阻塞状态，为false则线程为阻塞状态。 
      3）如果某个线程调用WaitOne方法，则当事件状态为终止状态时，该线程会得到信号，继续向下执行。

ManualResetEvent和AutoResetEvent的不同点： 
      1）AutoResetEvent.WaitOne()每次只允许一个线程进入，当某个线程得到信号后，AutoResetEvent会自动又将信号置为不发送状态，则其他调用WaitOne的线程只有继续等待，也就是说AutoResetEvent一次只唤醒一个线程； 
      2）ManualResetEvent则可以唤醒多个线程，因为当某个线程调用了ManualResetEvent.Set()方法后，其他调用WaitOne的线程获得信号得以继续执行，而ManualResetEvent不会自动将信号置为不发送。 
      3）也就是说，除非手工调用了ManualResetEvent.Reset()方法，则ManualResetEvent将一直保持有信号状态，ManualResetEvent也就可以同时唤醒多个线程继续执行。

示例场景：张三、李四两个好朋友去餐馆吃饭，两个人点了一份宫爆鸡丁，宫爆鸡丁做好需要一段时间，张三、李四不愿傻等，都专心致志的玩起了手机游戏，心想宫爆鸡丁做好了，服务员肯定会叫我们的。服务员上菜之后，张三李四开始享用美味的饭菜，饭菜吃光了，他们再叫服务员过来买单。我们可以从这个场景中抽象出来三个线程，张三线程、李四线程和服务员线程，他们之间需要同步：服务员上菜—>张三、李四开始享用宫爆鸡丁—>吃好后叫服务员过来买单。这个同步用什么呢？ ManualResetEvent还是AutoResetEvent？通过上面的分析不难看出，我们应该用ManualResetEvent进行同步，下面是程序代码：

张三李四吃饭的故事

C#代码  

  1. public class EventWaitTest
  2. {
  3. private string name; //顾客姓名
  4. //private static AutoResetEvent eventWait = new AutoResetEvent(false);
  5. private static ManualResetEvent eventWait = new ManualResetEvent(false);
  6. private static ManualResetEvent eventOver = new ManualResetEvent(false);
  7. public EventWaitTest(string name)
  8. {
  9. this.name = name;
  10. }
  11. public static void Product()
  12. {
  13. Console.WriteLine("服务员：厨师在做菜呢，两位稍等");
  14. Thread.Sleep(2000);
  15. Console.WriteLine("服务员：宫爆鸡丁好了");
  16. eventWait.Set();
  17. while (true)
  18. {
  19. if (eventOver.WaitOne(1000, false))
  20. {
  21. Console.WriteLine("服务员：两位请买单");
  22. eventOver.Reset();
  23. }
  24. }
  25. }
  26. public void Consume()
  27. {
  28. while (true)
  29. {
  30. if (eventWait.WaitOne(1000, false))
  31. {
  32. Console.WriteLine(this.name + "：开始吃宫爆鸡丁");
  33. Thread.Sleep(2000);
  34. Console.WriteLine(this.name + "：宫爆鸡丁吃光了");
  35. eventWait.Reset();
  36. eventOver.Set();
  37. break;
  38. }
  39. else
  40. {
  41. Console.WriteLine(this.name + "：等着上菜无聊先玩会手机游戏");
  42. }
  43. }
  44. }
  45. }
  46. public class App
  47. {
  48. public static void Main(string[] args)
  49. {
  50. EventWaitTest zhangsan = new EventWaitTest("张三");
  51. EventWaitTest lisi = new EventWaitTest("李四");
  52. Thread t1 = new Thread(new ThreadStart(zhangsan.Consume));
  53. Thread t2 = new Thread(new ThreadStart(lisi.Consume));
  54. Thread t3 = new Thread(new ThreadStart(EventWaitTest.Product));
  55. t1.Start();
  56. t2.Start();
  57. t3.Start();
  58. Console.Read();
  59. }
  60. }

编译后查看运行结果，符合我们的预期，控制台输出为： 
      服务员：厨师在做菜呢，两位稍等... 
      张三：等着上菜无聊先玩会手机游戏 
      李四：等着上菜无聊先玩会手机游戏 
      张三：等着上菜无聊先玩会手机游戏 
      李四：等着上菜无聊先玩会手机游戏 
      服务员：宫爆鸡丁好了 
      张三：开始吃宫爆鸡丁 
      李四：开始吃宫爆鸡丁 
      张三：宫爆鸡丁吃光了 
      李四：宫爆鸡丁吃光了 
      服务员：两位请买单

如果改用AutoResetEvent进行同步呢？会出现什么样的结果？恐怕张三和李四就要打起来了，一个享用了美味的宫爆鸡丁，另一个到要付账的时候却还在玩游戏。感兴趣的朋友可以把注释的那行代码注释去掉，并把下面一行代码注释掉，运行程序看会出现怎样的结果。

3.Mutex(互斥体）

Mutex和EventWaitHandler有着共同的父类WaitHandler类，它们同步的函数用法也差不多，这里不再赘述。Mutex的突出特点是可以跨应用程序域边界对资源进行独占访问，即可以用于同步不同进程中的线程，这种功能当然这是以牺牲更多的系统资源为代价的。

这种跨进程同步的一种应用是，限制同一台电脑中同时打开两个相同的程序。具体实现可以参考《用Mutex或进程限制用户在一台电脑上同时打开两个程序》。

时间： 2024-04-27 03:34:14

C#多线程：深入了解线程同步lock,Monitor,Mutex,同步事件和等待句柄（中）的相关文章

【转】多线程：C#线程同步lock,Monitor,Mutex,同步事件和等待句柄（上）

本篇从Monitor,Mutex,ManualResetEvent,AutoResetEvent,WaitHandler的类关系图开始,希望通过 本篇的介绍能对常见的线程同步方法有一个整体的认识,而对每种方式的使用细节,适用场合不会过多解释.让我们来看看这几个类的关系图: 1.lock关键字      lock是C#关键词,它将语句块标记为临界区,确保当一个线程位于代码的临界区时,另一个线程不进入临界区.如果其他线程试图进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放.方法是获取给定

C# 多线程(lock,Monitor,Mutex,同步事件和等待句柄)

本文来自:http://www.cnblogs.com/SkySoot/archive/2012/04/02/2430295.html 本篇从 Monitor,Mutex,ManualResetEvent,AutoResetEvent,WaitHandler 的类关系图开始,希望通过本篇的介绍能对常见的线程同步方法有一个整体的认识,而对每种方式的使用细节,适用场合不会过多解释. 让我们来看看这几个类的关系图: 1. lock 关键字     lock 是 C# 关键词,它将语句块标记为临界区,确

c# 中的 lock monitor mutex Semaphore 的比较

直接贴文章好了,这些大神都讲解的很清楚: c# 中的 mutex https://msdn.microsoft.com/en-us/library/system.threading.mutex(v=vs.110).aspx c# 中的 lock monitor mutex Semaphore  的比较 https://abhijit-k-adhikari.me/2012/04/17/lock-monitor-mutex-semaphore/ https://www.onlinebuff.com/

C#多线程同步事件及等待句柄AutoResetEvent 和 ManualResetEvent

最近捣鼓了一下多线程的同步问题,发现其实C#关于多线程同步事件处理还是很灵活,这里主要写一下,自己测试的一些代码,涉及到了AutoResetEvent 和 ManualResetEvent,当然还有也简要提了一下System.Threading.WaitHandle.WaitOne .System.Threading.WaitHandle.WaitAny和System.Threading.WaitHandle.WaitAll ,下面我们一最初学者的角度来看,多线程之间的同步. 假设有这样的一个场

C#各种同步方法 lock, Monitor,Mutex, Semaphore, Interlocked, ReaderWriterLock,AutoResetEvent, ManualResetEvent

看下组织结构: System.Object System.MarshalByRefObject System.Threading.WaitHandle System.Threading.Mutex System.Threading.Semaphore System.Threading.EventWaitHandle System.Threading.ManualResetEvent System.Threading.AutoResetEvent System.Object System.Thre

python类库32[多进程同步Lock+Semaphore+Event]

python类库32[多进程同步Lock+Semaphore+Event] 同步的方法基本与多线程相同. 1) Lock 当多个进程需要访问共享资源的时候,Lock可以用来避免访问的冲突. import multiprocessingimport sys def worker_with(lock, f):    with lock:        fs = open(f,"a+")        fs.write('Lock acquired via with\n')        f

C#多线程开发7：使用Monitor类同步多个线程

在<使用lock语句同步多个线程>的文章中,使用lock语句同步多线程访问临界资源. 使用lock语句的代码如下所示. private static object o = new object(); lock (o) { if (account >= 1000) { Thread.Sleep(10);//自动取款机打了个小盹 account -= 1000; pocket += 1000; } } 使用ILDASM工具查看上面代码对应的IL代码: 可以发现:lock语句被解析为调用Mon

线程同步 – lock和Monitor

在多线程代码中,多个线程可能会访问一些公共的资源(变量.方法逻辑等等),这些公共资源称为临界区(共享区):临界区的资源是不安全,所以需要通过线程同步对多个访问临界区的线程进行控制. 同样,有些时候我们需要多个线程按照特定的顺序执行,这时候,我们也需要进行线程同步. 下面,我们就看看C#中通过lock和Monitor进行线程同步. lock关键字 lock是一种非常简单而且经常使用的线程同步方式,lock 关键字将语句块标记为临界区. lock 确保当一个线程位于代码的临界区时,另一个线程不能进入

C#使用Monitor类、Lock和Mutex类进行多线程同步

在多线程中,为了使数据保持一致性必须要对数据或是访问数据的函数加锁,在数据库中这是很常见的,但是在程序中由于大部分都是单线程的程序,所以没有加锁的必要,但是在多线程中,为了保持数据的同步,一定要加锁,好在Framework中已经为我们提供了三个加锁的机制,分别是Monitor类.Lock关键字和Mutex类. 其中Lock关键词用法比较简单,Monitor类和Lock的用法差不多.这两个都是锁定数据或是锁定被调用的函数.而Mutex则多用于锁定多线程间的同步调用.简单的说,Monitor和Loc