zoukankan      html  css  js  c++  java

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

    前两篇简单介绍了线程同步lock，Monitor，同步事件EventWaitHandler，互斥体Mutex的基本用法，在此基础上，我们对它们用 法进行比较，并给出什么时候需要锁什么时候不需要的几点建议。最后，介绍几个FCL中线程安全的类，集合类的锁定方式等，做为对线程同步系列的完善和补 充。

          1.几种同步方法的区别

          lock和Monitor是.NET用一个特殊结构实现的，Monitor对象是完全托管的、完全可移植的，并且在操作系统资源要求方面可能更为有效，同 步速度较快，但不能跨进程同步。lock（Monitor.Enter和Monitor.Exit方法的封装），主要作用是锁定临界区，使临界区代码只能 被获得锁的线程执行。Monitor.Wait和Monitor.Pulse用于线程同步，类似信号操作，个人感觉使用比较复杂，容易造成死锁。

          互斥体Mutex和事件对象EventWaitHandler属于内核对象，利用内核对象进行线程同步，线程必须要在用户模式和内核模式间切换，所以一般效率很低，但利用互斥对象和事件对象这样的内核对象，可以在多个进程中的各个线程间进行同步。

          互斥体Mutex类似于一个接力棒，拿到接力棒的线程才可以开始跑，当然接力棒一次只属于一个线程(Thread Affinity)，如果这个线程不释放接力棒(Mutex.ReleaseMutex)，那么没办法，其他所有需要接力棒运行的线程都知道能等着看热 闹。

          EventWaitHandle 类允许线程通过发信号互相通信。通常，一个或多个线程在 EventWaitHandle 上阻止，直到一个未阻止的线程调用 Set 方法，以释放一个或多个被阻止的线程。

          2.什么时候需要锁定

          首先要理解锁定是解决竞争条件的，也就是多个线程同时访问某个资源，造成意想不到的结果。比如，最简单的情况是，一个计数器，两个线程同时加一，后果就是 损失了一个计数，但相当频繁的锁定又可能带来性能上的消耗，还有最可怕的情况死锁。那么什么情况下我们需要使用锁，什么情况下不需要呢？

          1）只有共享资源才需要锁定
          只有可以被多线程访问的共享资源才需要考虑锁定，比如静态变量，再比如某些缓存中的值，而属于线程内部的变量不需要锁定。

          2）多使用lock,少用Mutex
          如果你一定要使用锁定，请尽量不要使用内核模块的锁定机制，比如.NET的Mutex，Semaphore，AutoResetEvent和 ManuResetEvent，使用这样的机制涉及到了系统在用户模式和内核模式间的切换，性能差很多，但是他们的优点是可以跨进程同步线程，所以应该清 楚的了解到他们的不同和适用范围。

          3）了解你的程序是怎么运行的
          实际上在web开发中大多数逻辑都是在单个线程中展开的，一个请求都会在一个单独的线程中处理，其中的大部分变量都是属于这个线程的，根本没有必要考虑锁定，当然对于ASP.NET中的Application对象中的数据，我们就要考虑加锁了。

          4）把锁定交给数据库
          数据库除了存储数据之外，还有一个重要的用途就是同步，数据库本身用了一套复杂的机制来保证数据的可靠和一致性，这就为我们节省了很多的精力。保证了数据 源头上的同步，我们多数的精力就可以集中在缓存等其他一些资源的同步访问上了。通常，只有涉及到多个线程修改数据库中同一条记录时，我们才考虑加锁。

          5）业务逻辑对事务和线程安全的要求
          这条是最根本的东西，开发完全线程安全的程序是件很费时费力的事情，在电子商务等涉及金融系统的案例中，许多逻辑都必须严格的线程安全，所以我们不得不牺 牲一些性能，和很多的开发时间来做这方面的工作。而一般的应用中，许多情况下虽然程序有竞争的危险，我们还是可以不使用锁定，比如有的时候计数器少一多 一，对结果无伤大雅的情况下，我们就可以不用去管它。

          3.InterLocked类

          Interlocked 类提供了同步对多个线程共享的变量的访问的方法。如果该变量位于共享内存中，则不同进程的线程就可以使用该机制。互锁操作是原子的，即整个操作是不能由相 同变量上的另一个互锁操作所中断的单元。这在抢先多线程操作系统中是很重要的，在这样的操作系统中，线程可以在从某个内存地址加载值之后但是在有机会更改 和存储该值之前被挂起。

          我们来看一个InterLock.Increment()的例子，该方法以原子的形式递增指定变量并存储结果，示例如下：

    C#代码  收藏代码
    1. class InterLockedTest  
    2.     {  
    3.         public static Int64 i = 0;  
    4.   
    5.         public static void Add()  
    6.         {  
    7.             for (int i = 0; i < 100000000; i++)  
    8.             {  
    9.                 Interlocked.Increment(ref InterLockedTest.i);  
    10.                 //InterLockedTest.i = InterLockedTest.i + 1;  
    11.             }  
    12.         }  
    13.   
    14.   
    15.         public static void Main(string[] args)  
    16.         {  
    17.             Thread t1 = new Thread(new ThreadStart(InterLockedTest.Add));  
    18.             Thread t2 = new Thread(new ThreadStart(InterLockedTest.Add));  
    19.   
    20.             t1.Start();  
    21.             t2.Start();  
    22.   
    23.             t1.Join();  
    24.             t2.Join();  
    25.   
    26.             Console.WriteLine(InterLockedTest.i.ToString());  
    27.             Console.Read();  
    28.         }  
    29.     }  


    输出结果200000000，如果InterLockedTest.Add()方法中用注释掉的语句代替 Interlocked.Increment()方法，结果将不可预知，每次执行结果不同。InterLockedTest.Add()方法保证了加1操 作的原子性，功能上相当于自动给加操作使用了lock锁。同时我们也注意到InterLockedTest.Add()用时比直接用+号加1要耗时的多， 所以说加锁资源损耗还是很明显的。

          另外InterLockedTest类还有几个常用方法，具体用法可以参考MSDN上的介绍。
    4.集合类的同步

          .NET在一些集合类，比如Queue、ArrayList、HashTable和Stack，已经提供了一个供lock使用的对象SyncRoot。用Reflector查看了SyncRoot属性（Stack.SynchRoot略有不同）的源码如下：

    C#代码  收藏代码
    1. 转载  多线程：C#线程同步lock,Monitor,Mutex,同步事件和等待句柄（下） （转） 收藏  
    2.   
    3.    前两篇简单介绍了线程同步lock，Monitor， 同步事件EventWaitHandler，互斥体Mutex的基本用法，在此基础上，我们对它们用法进行比较，并给出什么时候需要锁什么时候不需要的几 点建议。最后，介绍几个FCL中线程安全的类，集合类的锁定方式等，做为对线程同步系列的完善和补充。  
    4.   
    5.       1.几种同步方法的区别  
    6.   
    7.       lock和Monitor是.NET用一个特殊结构实现的，Monitor对象是完全托管的、完全可移植的，并且在操作系统资源要求方面可能更为有效，同步速度较快，但不能跨进程同步。lock（Monitor.Enter和Monitor.Exit方法的封装），主要作用是锁定临界区，使临界区代码只能被获得锁的线程执行。Monitor.Wait和Monitor.Pulse用于线程同步，类似信号操作，个人感觉使用比较复杂，容易造成死锁。  
    8.   
    9.       互斥体Mutex和事件对象EventWaitHandler属于内核对象，利用内核对象进行线程同步，线程必须要在用户模式和内核模式间切换，所以一般效率很低，但利用互斥对象和事件对象这样的内核对象，可以在多个进程中的各个线程间进行同步。  
    10.   
    11.       互 斥体Mutex类似于一个接力棒，拿到接力棒的线程才可以开始跑，当然接力棒一次只属于一个线程(Thread Affinity)，如果这个线程不释放 接力棒(Mutex.ReleaseMutex)，那么没办法，其他所有需要接力棒运行的线程都知道能等着看热闹。  
    12.   
    13.       EventWaitHandle 类允许线程通过发信号互相通信。通常，一个或多个线程在 EventWaitHandle 上阻止，直到一个未阻止的线程调用 Set 方法，以释放一个或多个被阻止的线程。  
    14.   
    15.       2.什么时候需要锁定  
    16.   
    17.       首 先要理解锁定是解决竞争条件的，也就是多个线程同时访问某个资源，造成意想不到的结果。比如，最简单的情况是，一个计数器，两个线程同时加一，后果就是损 失了一个计数，但相当频繁的锁定又可能带来性能上的消耗，还有最可怕的情况死锁。那么什么情况下我们需要使用锁，什么情况下不需要呢？  
    18.   
    19.       1）只有共享资源才需要锁定  
    20.       只有可以被多线程访问的共享资源才需要考虑锁定，比如静态变量，再比如某些缓存中的值，而属于线程内部的变量不需要锁定。   
    21.   
    22.       2）多使用lock,少用Mutex  
    23.       如 果你一定要使用锁定，请尽量不要使用内核模块的锁定机制，比如.NET的Mutex，Semaphore，AutoResetEvent 和 ManuResetEvent，使用这样的机制涉及到了系统在用户模式和内核模式间的切换，性能差很多，但是他们的优点是可以跨进程同步线程，所以应 该清楚的了解到他们的不同和适用范围。  
    24.   
    25.       3）了解你的程序是怎么运行的  
    26.       实际上在web开发中大多数逻辑都是在单个线程中展开的，一个请求都会在一个单独的线程中处理，其中的大部分变量都是属于这个线程的，根本没有必要考虑锁定，当然对于ASP.NET中的Application对象中的数据，我们就要考虑加锁了。  
    27.   
    28.       4）把锁定交给数据库  
    29.       数 据库除了存储数据之外，还有一个重要的用途就是同步，数据库本身用了一套复杂的机制来保证数据的可靠和一致性，这就为我们节省了很多的精力。保证了数据源 头上的同步，我们多数的精力就可以集中在缓存等其他一些资源的同步访问上了。通常，只有涉及到多个线程修改数据库中同一条记录时，我们才考虑加锁。   
    30.   
    31.       5）业务逻辑对事务和线程安全的要求  
    32.       这 条是最根本的东西，开发完全线程安全的程序是件很费时费力的事情，在电子商务等涉及金融系统的案例中，许多逻辑都必须严格的线程安全，所以我们不得不牺牲 一些性能，和很多的开发时间来做这方面的工作。而一般的应用中，许多情况下虽然程序有竞争的危险，我们还是可以不使用锁定，比如有的时候计数器少一多一， 对结果无伤大雅的情况下，我们就可以不用去管它。  
    33.   
    34.       3.InterLocked类  
    35.   
    36.       Interlocked 类 提供了同步对多个线程共享的变量的访问的方法。如果该变量位于共享内存中，则不同进程的线程就可以使用该机制。互锁操作是原子的，即整个操作是不能由相同 变量上的另一个互锁操作所中断的单元。这在抢先多线程操作系统中是很重要的，在这样的操作系统中，线程可以在从某个内存地址加载值之后但是在有机会更改和 存储该值之前被挂起。  
    37.   
    38.       我们来看一个InterLock.Increment()的例子，该方法以原子的形式递增指定变量并存储结果，示例如下：  
    39. Increment()方法累加的示例  
    40.     class InterLockedTest  
    41.     {  
    42.         public static Int64 i = 0;  
    43.   
    44.         public static void Add()  
    45.         {  
    46.             for (int i = 0; i < 100000000; i++)  
    47.             {  
    48.                 Interlocked.Increment(ref InterLockedTest.i);  
    49.                 //InterLockedTest.i = InterLockedTest.i + 1;  
    50.             }  
    51.         }  
    52.   
    53.   
    54.         public static void Main(string[] args)  
    55.         {  
    56.             Thread t1 = new Thread(new ThreadStart(InterLockedTest.Add));  
    57.             Thread t2 = new Thread(new ThreadStart(InterLockedTest.Add));  
    58.   
    59.             t1.Start();  
    60.             t2.Start();  
    61.   
    62.             t1.Join();  
    63.             t2.Join();  
    64.   
    65.             Console.WriteLine(InterLockedTest.i.ToString());  
    66.             Console.Read();  
    67.         }  
    68.     }  
    69.   
    70.       输 出结果200000000，如果InterLockedTest.Add()方法中用注释掉的语句代替Interlocked.Increment()方 法，结果将不可预知，每次执行结果不同。InterLockedTest.Add()方法保证了加1操作的原子性，功能上相当于自动给加操作使用了lock锁。同时我们也注意到InterLockedTest.Add()用时比直接用+号加1要耗时的多，所以说加锁资源损耗还是很明显的。  
    71.   
    72.       另外InterLockedTest类还有几个常用方法，具体用法可以参考MSDN上的介绍。  
    73.   
    74.       4.集合类的同步  
    75.   
    76.       .NET在一些集合类，比如Queue、ArrayList、HashTable和Stack，已经提供了一个供lock使用的对象SyncRoot。用Reflector查看了SyncRoot属性（Stack.SynchRoot略有不同）的源码如下：  
    77. SyncRoot属性源码  
    78. public virtual object SyncRoot  
    79. {  
    80.     get  
    81.     {  
    82.         if (this._syncRoot == null)  
    83.         {  
    84.             //如果_syncRoot和null相等，将new object赋值给_syncRoot  
    85.             //Interlocked.CompareExchange方法保证多个线程在使用syncRoot时是线程安全的  
    86.             Interlocked.CompareExchange(ref this._syncRoot, new object(), null);  
    87.         }  
    88.         return this._syncRoot;  
    89.     }  
    90. }  


    这里要特别注意的是MSDN提到：从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。即使一个集合已进行同步，其他线程仍可以修改该集 合，这将导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。应该使用下面 的代码：

    C#代码  收藏代码
    1. Queue q = new Queue();  
    2.     lock (q.SyncRoot)  
    3.     {  
    4.         foreach (object item in q)  
    5.         {  
    6.             //do something  
    7.         }  
    8.     }  


    还有一点需要说明的是，集合类提供了一个是和同步相关的方法 Synchronized，该方法返回一个对应的集合类的wrapper类，该类是线程安全的，因为他的大部分方法都用lock关键字进行了同步处理。如 HashTable的Synchronized返回一个新的线程安全的HashTable实例，代码如下：

    C#代码  收藏代码
    1. //在多线程环境中只要我们用下面的方式实例化HashTable就可以了  
    2.     Hashtable ht = Hashtable.Synchronized(new Hashtable());  
    3.   
    4.     //以下代码是.NET Framework Class Library实现，增加对Synchronized的认识  
    5.     [HostProtection(SecurityAction.LinkDemand, Synchronization=true)]  
    6.     public static Hashtable Synchronized(Hashtable table)  
    7.     {  
    8.         if (table == null)  
    9.         {  
    10.             throw new ArgumentNullException("table");  
    11.         }  
    12.         return new SyncHashtable(table);  
    13.     }  
    14.   
    15.    
    16.     //SyncHashtable的几个常用方法，我们可以看到内部实现都加了lock关键字保证线程安全  
    17.     public override void Add(object key, object value)  
    18.     {  
    19.         lock (this._table.SyncRoot)  
    20.         {  
    21.             this._table.Add(key, value);  
    22.         }  
    23.     }  
    24.   
    25.     public override void Clear()  
    26.     {  
    27.         lock (this._table.SyncRoot)  
    28.         {  
    29.             this._table.Clear();  
    30.         }  
    31.     }  
    32.   
    33.     public override void Remove(object key)  
    34.     {  
    35.         lock (this._table.SyncRoot)  
    36.         {  
    37.             this._table.Remove(key);  
    38.         }  
    39.     }  


    线程同步是一个非常复杂的话题，这里只是根据公司的一个项目把相关的知识整理出来，作为工作的一种总结。这些同步方法的使用场景是怎样的？究竟有哪些细微的差别？还有待于进一步的学习和实践。
  • 相关阅读:
    如何理解Stand SPI Dual SPI 和Quad SPI??
    一款很实用的欠压过压保护电路
    AbpZero之企业微信登录（拓展第三方auth授权登录）第三步：需要注意事项
    在AbpZero中hangfire后台作业的使用——开启hangfire
    AbpZero之企业微信登录（拓展第三方auth授权登录）第一步：查看AbpZero的auth第三方登录的底层机制
    在AbpZero中hangfire后台作业的使用——hangfire的调度
    AbpZero后台模块化(1)
    AbpZero之企业微信登录（拓展第三方auth授权登录）第二步：开始逐步实现企业微信登录
    vue基础（入门视频零基础精华总结）
    组件参数校验与非props特性
  • 原文地址：https://www.cnblogs.com/lizhizhang/p/3751694.html
Copyright © 2011-2022 走看看