C#线程同步方法汇总

　我们在编程的时候，有时会使用多线程来解决问题，比如你的程序需要在 后台处理一大堆数据，但还要使用户界面处于可操作状态；或者你的程序需要访问一些外部资源如数据库或网络文件等。这些情况你都可以创建一个子线程去处理， 然而，多线程不可避免地会带来一个问题，就是线程同步的问题。如果这个问题处理不好，我们就会得到一些非预期的结果。

　　在网上也看过一些关于线程同步的文章，其实线程同步有好几种方法，下面我就简单的做一下归纳。

　　一、volatile关键字

　　volatile是最简单的一种同步方法，当然简单是要付出代价的。它只能在变量一级做同步，volatile的含义就是告诉处理器， 不要将我放入工作内存， 请直接在主存操作我。（【转自www.bitsCN.com】）因此，当多线程同时访问该变量时，都将直接操作主存，从本质上做到了变量共享。

　　能够被标识为volatile的必须是以下几种类型：（摘自MSDN）

• Any reference type.
• Any pointer type (in an unsafe context).
• The types sbyte, byte, short, ushort, int, uint, char, float, bool.
• An enum type with an enum base type of byte, sbyte, short, ushort, int, or uint.

  　　如：

  Code publicclassA { PRivatevolatileint_i; publicintI { get{return_i; } set{ _i=value; } } }

  　　但volatile并不能实现真正的同步，因为它的操作级别只停留在变量级别，而不是原子级别。如果是在单处理器系统中，是没有任何问题的，变量在主存中没有机会被其他人修改，因为只有一个处理器，这就叫作processor Self-Consistency。但在多处理器系统中，可能就会有问题。每个处理器都有自己的data cach，而且被更新的数据也不一定会立即写回到主存。所以可能会造成不同步，但这种情况很难发生，因为cach的读写速度相当快，flush的频率也相当高，只有在压力测试的时候才有可能发生，而且几率非常非常小。

  　　二、lock关键字

  　　lock是一种比较好用的简单的线程同步方式，它是通过为给定对象获取互斥锁来实现同步的。它可以保证当一个线程在关键代码段的时候，另一个线程不会进来，它只能等待，等到那个线程对象被释放，也就是说线程出了临界区。用法：

  Code publicvoidFunction() { objectlockThis=newobject(); lock(lockThis) { //access thread-sensitive resources. } }
  　　lock的参数必须是基于引用类型的对象，不要是基本类型像 bool,int什么的，这样根本不能同步，原因是lock的参数要求是对象，如果传入int，势必要发生装箱操作，这样每次lock的都将是一个新的不 同的对象。最好避免使用public类型或不受程序控制的对象实例，因为这样很可能导致死锁。特别是不要使用字符串作为lock的参数，因为字符串被 CLR“暂留”，就是说整个应用程序中给定的字符串都只有一个实例，因此更容易造成死锁现象。建议使用不被“暂留”的私有或受保护成员作为参数。其实某些 类已经提供了专门用于被锁的成员，比如Array类型提供SyncRoot，许多其它集合类型也都提供了SyncRoot。

  　　所以，使用lock应该注意以下几点：　

  　　１、如果一个类的实例是public的，最好不要lock(this)。因为使用你的类的人也许不知道你用了lock，如果他new了一个实例，并且对这个实例上锁，就很容易造成死锁。

  　　２、如果MyType是public的，不要lock(typeof(MyType))

  　　３、永远也不要lock一个字符串

  　　三、System.Threading.Interlocked

  　　对于整数数据类型的简单操作，可以用Interlocked类的成员来实现线程同步，存在于System.Threading命名空间。Interlocked类有以下方法：Increment,Decrement,Exchange和CompareExchange。使用Increment和Decrement可以保证对一个整数的加减为一个原子操作。Exchange方法自动交换指定变量的值。CompareExchange方法组合了两个操作：比较两个值以及根据比较的结果将第三个值存储在其中一个变量中。比较和交换操作也是按原子操作执行的。如：

  Code inti=0; System.Threading.Interlocked.Increment(refi); Console.WriteLine(i); System.Threading.Interlocked.Decrement(refi); Console.WriteLine(i); System.Threading.Interlocked.Exchange(refi,100); Console.WriteLine(i); System.Threading.Interlocked.CompareExchange(refi,10,100);

  Output:

  

  　　四、Monitor

  　　Monitor类提供了与lock类似的功能,不过与lock不同的是,它 能更好的控制同步块,当调用了Monitor的Enter(Object o)方法时,会获取o的独占权,直到调用Exit(Object o)方法时,才会释放对o的独占权,可以多次调用Enter(Object o)方法,只需要调用同样次数的Exit(Object o)方法即可,Monitor类同时提供了TryEnter(Object o,[int])的一个重载方法,该方法尝试获取o对象的独占权,当获取独占权失败时,将返回false。

  　　但使用lock通常比直接使用Monitor更可取，一方面是因为lock更简洁，另一方面是因为lock确保了即使受保护的代码引发异常，也可以释放基础监视器。这是通过finally中调用Exit来实现的。事实上，lock就是用Monitor类来实现的。下面两段代码是等效的：

  Code lock(x) { DoSomething(); }等效于objectobj=(object)x; System.Threading.Monitor.Enter(obj); try { DoSomething(); } finally { System.Threading.Monitor.Exit(obj); }

  关于用法，请参考下面的代码：

  Code privatestaticobjectm_monitorObject=newobject(); [STAThread] staticvoidMain(string[] args) { Thread thread=newThread(newThreadStart(Do)); thread.Name="Thread1"; Thread thread2=newThread(newThreadStart(Do)); thread2.Name="Thread2"; thread.Start(); thread2.Start(); thread.Join(); thread2.Join(); Console.Read(); } staticvoidDo() { if(!Monitor.TryEnter(m_monitorObject)) { Console.WriteLine("Can't visit Object"+Thread.CurrentThread.Name); return; } try { Monitor.Enter(m_monitorObject); Console.WriteLine("Enter Monitor"+Thread.CurrentThread.Name); Thread.Sleep(5000); } finally { Monitor.Exit(m_monitorObject); } }

  　　当线程1获取了m_monitorObject对象独占权时，线程2尝试调用TryEnter(m_monitorObject)，此时会由于无法获取独占权而返回false，输出信息如下：

  　　另外，Monitor还提供了三个静态方法 Monitor.Pulse(Object o)，Monitor.PulseAll(Object o)和Monitor.Wait(Object o ) ，用来实现一种唤醒机制的同步。关于这三个方法的用法，可以参考MSDN，这里就不详述了。

  　　五、Mutex

  　　在使用上,Mutex与上述的Monitor比较接近，不过Mutex不具 备Wait，Pulse，PulseAll的功能，因此，我们不能使用Mutex实现类似的唤醒的功能。不过Mutex有一个比较大的特点，Mutex是 跨进程的，因此我们可以在同一台机器甚至远程的机器上的多个进程上使用同一个互斥体。尽管Mutex也可以实现进程内的线程同步，而且功能也更强大，但这 种情况下，还是推荐使用Monitor，因为Mutex类是win32封装的，所以它所需要的互操作转换更耗资源。

  　　六、ReaderWriterLock

  　　在考虑资源访问的时候,惯性上我们会对资源实施lock机制,但是在某些情 况下,我们仅仅需要读取资源的数据,而不是修改资源的数据,在这种情况下获取资源的独占权无疑会影响运行效率,因此.Net提供了一种机制,使用 ReaderWriterLock进行资源访问时,如果在某一时刻资源并没有获取写的独占权,那么可以获得多个读的访问权,单个写入的独占权,如果某一时 刻已经获取了写入的独占权,那么其它读取的访问权必须进行等待,参考以下代码：

  Code privatestaticReaderWriterLock m_readerWriterLock=newReaderWriterLock(); privatestaticintm_int=0; [STAThread] staticvoidMain(string[] args) { Thread readThread=newThread(newThreadStart(Read)); readThread.Name="ReadThread1"; Thread readThread2=newThread(newThreadStart(Read)); readThread2.Name="ReadThread2"; Thread writeThread=newThread(newThreadStart(Writer)); writeThread.Name="WriterThread"; readThread.Start(); readThread2.Start(); writeThread.Start(); readThread.Join(); readThread2.Join(); writeThread.Join();Console.ReadLine();