C#线程同步技术之Monitor

开发 后端
本文继续C#线程系列讲座之五,即C#线程同步技术之Monitor 。

在上一讲介绍了使用lock来实现线程之间的同步。实际上,这个lock是C#线程的一个障眼法,在C#编译器编译lock语句时,将其编译成了调用Monitor类。先看看下面的C#源代码:

C#线程同步:Monitor

  1. public static void MyLock()  
  2. {  
  3.     lock (typeof(Program))  
  4.     {  
  5.     }  
  6. }  
  7.  

上面的代码通过lock语句使MyLock同步,这个方法被编译成IL后,代码如图1所示。

代码如图1 

 图1

从上图被标注的区域可以看到,一条lock语句被编译成了调用Monitor的Enter和Exit方法。Monitor在System.Threading命名空间中。lock的功能就相当于直接调用Monitor的Entry方法,所不同的是,lock方法在结束后,会自动解除锁定,当然,在IL中是调用了Monitor的Exit方法,但在C#程序中,看起来是自动解锁的,这类似于C#中的using语句,可以自动释放数据库等的资源。但如果直接在C#源程序中使用Monitor类,就必须调用Exit方法来显式地解除锁定。如下面的代码所示:

  1. Monitor.Entry(lockObj);  
  2. try 
  3. {  
  4.     // lockObj的同布区  
  5. }  
  6. catch(Exception e)  
  7. {  
  8.     // 异常处理代码  
  9. }  
  10. finally 
  11. {  
  12.     Monitor.Exit(lockObj);  // 解除锁定  
  13. }  
  14.  

Exit方法最后在finally里调用,这样无论在方法在发生异常、返回还是正常执行,都会执行到finally,并调用Exit方法解除锁定。

Monitor类不仅可以完全取代lock语句(如果只使用lock语句本身的功能,最好还是直接用lock语句吧),还可以使用TryEntry方法设置一个锁定超时,单位是毫秒。如下面的代码所示:

C#线程同步:Monitor.TryEntry

  1. if(Monitor.TryEntry(lockObj, 1000))  
  2. {  
  3.     try 
  4.     {  
  5.     }  
  6.     finally 
  7.     {  
  8.         Monitor.Exit(lockObj);  
  9.     }  
  10. }  
  11. else 
  12. {  
  13.     // 超时后的处理代码  
  14. }  
  15.  

上面的代码设置了锁定超时时间为1秒,也就是说,在1秒中后,lockObj还未被解锁,TryEntry方法就会返回false,如果在1秒之内,lockObj被解锁,TryEntry返回true。我们可以使用这种方法来避免死锁,如下面的代码所示:

  1. class Program  
  2. {  
  3.     private static Object objA = new Object();  
  4.     private static Object objB = new Object();  
  5.     public static void LockA()  
  6.     {  
  7.         if (Monitor.TryEnter(objA, 1000))  
  8.         {  
  9.             Thread.Sleep(1000);  
  10.             if (Monitor.TryEnter(objB, 2000))  
  11.             {  
  12.                 Monitor.Exit(objB);  
  13.             }  
  14.             else 
  15.             {  
  16.  
  17.                 Console.WriteLine("LockB timeout");  
  18.             }  
  19.             Monitor.Exit(objA);  
  20.         }  
  21.         Console.WriteLine("LockA");  
  22.     }  
  23.     public static void LockB()  
  24.     {  
  25.         if (Monitor.TryEnter(objB, 2000))  
  26.         {  
  27.             Thread.Sleep(2000);  
  28.             if (Monitor.TryEnter(objA, 1000))  
  29.             {  
  30.                 Monitor.Exit(objA);  
  31.             }  
  32.             else 
  33.             {  
  34.                 Console.WriteLine("LockA timeout");  
  35.             }  
  36.             Monitor.Exit(objB);  
  37.         }  
  38.         Console.WriteLine("LockB");  
  39.     }  
  40.     public static void Main()  
  41.     {  
  42.         Thread threadA = new Thread(LockA);  
  43.         Thread threadB = new Thread(LockB);  
  44.         threadA.Start();  
  45.         threadB.Start();  
  46.         Thread.Sleep(4000);           
  47.         Console.WriteLine("线程结束");  
  48.     }  
  49. }  

上面的代码是在上一讲举的死锁的例子,但在这一讲将lock语句改成了TryEntry方法,而且设置了锁定超时间,由于在等待一定时间后,不管被锁定的对象是否被解锁,TryEntry方法都会返回,因此,上面的代码是不会死锁的。运行上面的代码的结果如图2所示。

代码的结果如图2 

 图2

如果TryEntry方法的超时时间为System.Threading.Timeout.Infinite,TryEntry方法就相当于Entry方法,如果超时时间为0,不管是否解锁,TryEntry方法都会立即返回。

以上就是C#线程同步技术Monitor的使用,希望对大家有所帮助。

【编辑推荐】

  1. C#自定义特性介绍
  2. C#内置特性介绍
  3. 如何进行C#异常类的自定义
  4. C#编程技巧七条
  5. 预测C#与.NET的发展趋势
责任编辑:book05 来源: csdn
相关推荐

2009-09-04 14:41:09

C#同步线程

2009-08-04 17:57:41

C#线程同步死锁

2009-08-13 13:31:13

锁定对象C# Monitor类

2009-09-07 13:19:44

C#线程同步

2024-02-27 10:44:58

C#线程后端

2011-08-30 15:44:57

C#

2021-09-09 07:16:00

C#多线程开发

2010-12-21 14:21:36

线程C#

2009-08-18 09:26:07

C#线程功能

2009-08-25 15:09:30

C#线程的启动

2009-08-25 17:59:49

C#入门

2009-08-12 18:04:44

编写C#多线程

2009-08-12 13:11:24

C#实现远程线程插入

2009-08-18 09:33:49

C#特有线程功能

2009-09-07 13:02:52

Java和C#线程

2009-08-28 16:51:32

C#线程控制

2010-01-21 11:23:49

Linux多线程同步消息队列

2010-01-21 11:22:35

Linux多线程同步

2009-08-12 16:22:29

C#插件技术

2021-02-09 09:53:11

C#多线程异步
点赞
收藏

51CTO技术栈公众号