【转】多线程：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.     }  


线程同步是一个非常复杂的话题，这里只是根据公司的一个项目把相关的知识整理出来，作为工作的一种总结。这些同步方法的使用场景是怎样的？究竟有哪些细微的差别？还有待于进一步的学习和实践。

posted @ 2014-05-25 22:08  李志章  阅读(176)  评论(0)  编辑  收藏  举报