C#线程同步技术之Monitor

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

创新互联是一家专业提供任县企业网站建设,专注与成都做网站、成都网站制作、H5高端网站建设、小程序制作等业务。10年已为任县众多企业、政府机构等服务。创新互联专业网站建设公司优惠进行中。

C#线程同步：Monitor

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

上面的代码通过lock语句使MyLock同步，这个方法被编译成IL后，代码如图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.   
  
  
  
  2. try 
    3.   
  
  
  
  3. {  
    4.   
  
  
  
  4.     // lockObj的同布区  
    5.   
  
  
  
  5. }  
    6.   
  
  
  
  6. catch(Exception e)  
    7.   
  
  
  
  7. {  
    8.   
  
  
  
  8.     // 异常处理代码  
    9.   
  
  
  
  9. }  
    10.   
  
  
  
  10. finally 
    11.   
  
  
  
  11. {  
    12.   
  
  
  
  12.     Monitor.Exit(lockObj);  // 解除锁定  
    13.   
  
  
  
  13. }  
    14.   
  
  
  
  14.  
    15.

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

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

C#线程同步：Monitor.TryEntry

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

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

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

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

 图2

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

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

文章标题：C#线程同步技术之Monitor
网页路径：http://www.shufengxianlan.com/qtweb/news1/58401.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

全网营销推广知识

同城分类信息

东电技服　　 　力比特工程　　 　西信服务器托管　　 　成都网站建设公司　　 　联通机房服务器托管　　 　中国西部信息中心　　 　遂宁网站建设　　 　不锈钢防护栏　　 　红锐电子　　 　鳄鱼养殖　　 　成都网站设计　　 　网站建设方案　　 　无边发光字制作　　 　成都网站建设　　 　成都品牌网站设计　　 　定制网站设计　　 　江油网站建设　　 　成都宣传画册设计　　 　混凝土搅拌车　　 　香港主机