C#中的Mutex和Lock以及Monitor有什么区别吗？

C#语言有很多值得学习的地方，这里我们主要介绍C# Mutex对象，包括介绍控制好多个线程相互之间的联系等方面。
如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：System.Threading 命名空间中的 Mutex 类。
我们可以把Mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与C# Mutex对象的关系也正是如此，线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放，如果它等待的C# Mutex对象被释放了，它就自动拥有这个对象，直到它调用Mutex.ReleaseMutex()方法释放这个对象，而在此期间，其他想要获取这个C# Mutex对象的线程都只有等待。
下面这个例子使用了C# Mutex对象来同步四个线程，主线程等待四个线程的结束，而这四个线程的运行又是与两个C# Mutex对象相关联的。
其中还用到AutoResetEvent类的对象，可以把它理解为一个信号灯。这里用它的有信号状态来表示一个线程的结束。
1. using System;  
2. using System.Threading;  
3.
4. namespace ThreadExample  
5. {  
6. public class MutexSample  
7. {  
8. static Mutex gM1;  
9. static Mutex gM2;  
10. const int ITERS = 100;  
11. static AutoResetEvent Event1 = new AutoResetEvent(false);  
12. static AutoResetEvent Event2 = new AutoResetEvent(false);  
13. static AutoResetEvent Event3 = new AutoResetEvent(false);  
14. static AutoResetEvent Event4 = new AutoResetEvent(false);  
15.
16. public static void Main(String[] args)  
17. {  
18. Console.WriteLine("Mutex Sample ");  
19. //创建一个Mutex对象，并且命名为MyMutex  
20. gM1 = new Mutex(true,"MyMutex");  
21. //创建一个未命名的Mutex 对象.  
22. gM2 = new Mutex(true);  
23. Console.WriteLine(" - Main Owns gM1 and gM2");  
24.
25. AutoResetEvent[] evs = new AutoResetEvent[4];  
26. evs[0] = Event1; //为后面的线程t1,t2,t3,t4定义AutoResetEvent对象  
27. evs[1] = Event2;  
28. evs[2] = Event3;  
29. evs[3] = Event4;  
30.
31. MutexSample tm = new MutexSample( );  
32. Thread t1 = new Thread(new ThreadStart(tm.t1Start));  
33. Thread t2 = new Thread(new ThreadStart(tm.t2Start));  
34. Thread t3 = new Thread(new ThreadStart(tm.t3Start));  
35. Thread t4 = new Thread(new ThreadStart(tm.t4Start));  
36. t1.Start( );// 使用Mutex.WaitAll()方法等待一个Mutex数组中的对象全部被释放  
37. t2.Start( );// 使用Mutex.WaitOne()方法等待gM1的释放  
38. t3.Start( );// 使用Mutex.WaitAny()方法等待一个Mutex数组中任意一个对象被释放  
39. t4.Start( );// 使用Mutex.WaitOne()方法等待gM2的释放  
40.
41. Thread.Sleep(2000);  
42. Console.WriteLine(" - Main releases gM1");  
43. gM1.ReleaseMutex( ); //线程t2,t3结束条件满足  
44.
45. Thread.Sleep(1000);  
46. Console.WriteLine(" - Main releases gM2");  
47. gM2.ReleaseMutex( ); //线程t1,t4结束条件满足  
48.
49. //等待所有四个线程结束  
50. WaitHandle.WaitAll(evs);  
51. Console.WriteLine(" Mutex Sample");  
52. Console.ReadLine();  
53. }  
54.
55. public void t1Start( )  
56. {  
57. Console.WriteLine("t1Start started, Mutex.WaitAll(Mutex[])");  
58. Mutex[] gMs = new Mutex[2];  
59. gMs[0] = gM1;//创建一个Mutex数组作为Mutex.WaitAll()方法的参数  
60. gMs[1] = gM2;  
61. Mutex.WaitAll(gMs);//等待gM1和gM2都被释放  
62. Thread.Sleep(2000);  
63. Console.WriteLine("t1Start finished, Mutex.WaitAll(Mutex[]) satisfied");  
64. Event1.Set( ); //线程结束，将Event1设置为有信号状态  
65. }  
66. public void t2Start( )  
67. {  
68. Console.WriteLine("t2Start started, gM1.WaitOne( )");  
69. gM1.WaitOne( );//等待gM1的释放  
70. Console.WriteLine("t2Start finished, gM1.WaitOne( ) satisfied");  
71. Event2.Set( );//线程结束，将Event2设置为有信号状态  
72. }  
73. public void t3Start( )  
74. {  
75. Console.WriteLine("t3Start started, Mutex.WaitAny(Mutex[])");  
76. Mutex[] gMs = new Mutex[2];  
77. gMs[0] = gM1;//创建一个Mutex数组作为Mutex.WaitAny()方法的参数  
78. gMs[1] = gM2;  
79. Mutex.WaitAny(gMs);//等待数组中任意一个Mutex对象被释放  
80. Console.WriteLine("t3Start finished, Mutex.WaitAny(Mutex[])");  
81. Event3.Set( );//线程结束，将Event3设置为有信号状态  
82. }  
83. public void t4Start( )  
84. {  
85. Console.WriteLine("t4Start started, gM2.WaitOne( )");  
86. gM2.WaitOne( );//等待gM2被释放  
87. Console.WriteLine("t4Start finished, gM2.WaitOne( )");  
88. Event4.Set( );//线程结束，将Event4设置为有信号状态  
89. }  
90. }  
91. }

C#中使用Monitor类、Lock和Mutex类来同步多线程的执行         在多线程中，为了使数据保持一致性必须要对数据或是访问数据的函数加锁，在数据库中这是很常见的，但是在程序中由于大部分都是单线程的程序，所以没有加锁的必要，但是在多线程中，为了保持数据的同步，一定要加锁，好在Framework中已经为我们提供了三个加锁的机制，分别是Monitor类、Lock关键字和Mutex类。        其中Lock关键词用法比较简单，Monitor类和Lock的用法差不多。这两个都是锁定数据或是锁定被调用的函数。而Mutex则多用于锁定多线程间的同步调用。简单的说，Monitor和Lock多用于锁定被调用端，而Mutex则多用锁定调用端。例如下面程序：由于这种程序都是毫秒级的，所以运行下面的程序可能在不同的机器上有不同的结果，在同一台机器上不同时刻运行也有不同的结果，我的测试环境为vs2005, windowsXp , CPU3.0 , 1 G monery。        程序中有两个线程thread1、thread2和一个TestFunc函数，TestFunc会打印出调用它的线程名和调用的时间(mm级的)，两个线程分别以30mm和100mm来调用TestFunc这个函数。TestFunc执行的时间为50mm。程序如下：using System;using System.Collections.Generic;using System.Text;using System.Threading;namespace MonitorLockMutex{    class Program    {        #region variable        Thread thread1 = null;        Thread thread2 = null;        Mutex mutex = null;        #endregion        static void Main(string[] args)        {            Program p = new Program();            p.RunThread();            Console.ReadLine();        }        public Program()         {            mutex = new Mutex();            thread1 = new Thread(new ThreadStart(thread1Func));            thread2 = new Thread(new ThreadStart(thread2Func));        }        public void RunThread()        {            thread1.Start();             thread2.Start();        }        private void thread1Func()        {            for (int count = 0; count < 10; count++)            {                TestFunc("Thread1 have run " + count.ToString() + " times");                Thread.Sleep(30);             }        }        private void thread2Func()        {            for (int count = 0; count < 10; count++)            {                TestFunc("Thread2 have run " + count.ToString() + " times");                Thread.Sleep(100);           }        }        private void TestFunc(string str)        {            Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());            Thread.Sleep(50);        }    }}运行结果如下：        可以看出如果不加锁的话，这两个线程基本上是按照各自的时间间隔+TestFunc的执行时间(50mm)对TestFunc函数进行读取。因为线程在开始时需要分配内存，所以第0次的调用不准确，从第1~9次的调用可以看出，thread1的执行间隔约是80mm，thread2的执行间隔约是150mm。现在将TestFunc修改如下：private void TestFunc(string str){   lock (this)   {      Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());      Thread.Sleep(50);   }}或者是用Monitor也是一样的，如下：private void TestFunc(string str){      Monitor.Enter(this);      Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());      Thread.Sleep(50);      Monitor.Exit(this);}其中Enter和Exit都是Monitor中的静态方法。运行Lock结果如下：        让我们分析一下结果，同样从第1次开始。相同线程间的调用时间间隔为线程执行时间+TestFunc调用时间，不同线程间的调用时间间隔为TestFunc调用时间。例如：连续两次调用thread1之间的时间间隔约为30+50=80;连续两次调用thread2之间的时间间隔约为100+50=150mm。调用thread1和thread2之间的时间间隔为50mm。因为TestFunc被lock住了，所以一个thread调用TestFunc后，当其它的线程也同时调用TestFunc时，后来的线程即进被排到等待队列中等待，直到拥有访问权的线程释放这个资源为止。        这就是锁定被调用函数的特性，即只能保证每次被一个线程调用，线程优先级高的调用的次数就多，低的就少，这就是所谓的强占式。        下面让我们看看Mutex类的使用方法，以及与Monitor和Lock的区别。将代码修改如下：        private void thread1Func()        {            for (int count = 0; count < 10; count++)            {                mutex.WaitOne();                TestFunc("Thread1 have run " + count.ToString() + " times");                mutex.ReleaseMutex();            }        }        private void thread2Func()        {            for (int count = 0; count < 10; count++)            {                mutex.WaitOne();                TestFunc("Thread2 have run " + count.ToString() + " times");                mutex.ReleaseMutex();            }        }        private void TestFunc(string str)        {            Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());            Thread.Sleep(50);        }运行结果如下：        可以看出，Mutex只能互斥线程间的调用，但是不能互斥本线程的重复调用，即thread1中waitOne()只对thread2中的waitOne()起到互斥的作用，但是thread1并不受本wainOne()的影响，可以调用多次，只是在调用结束后调用相同次数的ReleaseMutex()就可以了。        那么如何使线程按照调用顺序来依次执行呢？其实把lock和Mutex结合起来使用就可以了，改代码如下：        private void thread1Func()        {            for (int count = 0; count < 10; count++)            {                lock (this)                {                    mutex.WaitOne();                    TestFunc("Thread1 have run " + count.ToString() + " times");                    mutex.ReleaseMutex();                }            }        }        private void thread2Func()        {            for (int count = 0; count < 10; count++)            {                lock (this)                {                    mutex.WaitOne();                    TestFunc("Thread2 have run " + count.ToString() + " times");                     mutex.ReleaseMutex();                }            }        }

参考文章：http://hi.baidu.com/zhenghanzheng/blog/item/17bfbd09fca0ec86d0581b0e.html