五 C# 多线程研究 使用Mutex类来同步方法及其与Monitor类和Lock之间的区别

　　Framework为我们提供了三个加锁的机制，分别是Monitor类、Lock关 键字和Mutex类。

　　总体而言，lock和monitor可以锁定对象，也可以锁定函数；而mutex一般用于锁定函数，并保证不同线程间同步调用函数，而不会受线程优先级影响。使用lock和monitor对象锁定对象时（即在对象外部锁定，或者在对象中的函数被调用的地方锁定对象），可以保证该对象一次只被一个线程所访问，但前提是：多个线程所锁定的对象必须是同一个对象，因此这种情况下应该定义一个全局的对象；锁定函数时，即在对象中的函数内部加锁，也可以保证该函数一次只被一个线程所访问，但前提也是各个线程访问的是同一个对象的该函数。而无论lock和monitor事锁定对象还是函数，都无法保证函数在不同线程间的同步，即函数不会被不同线程依次访问，而是优先级高的线程会一直霸占该对象或对象中的该函数，霸占一会儿，才会让给其他线程“霸占”；只有将lock和mutex一起使用，才能让函数的优先级失效，保证方法的同步。mutex对象一般在函数内部加锁，而不是在调用函数的地方。

　　综上所述，这三把锁的异同点如下：

　　（1）monitor一般在函数调用方加锁；mutex一般在函数内部加锁，即锁定被调用端；而lock则介于两者之间，调用方和被调用方通吃；

　　（2）使用monitor和lock给调用方加锁时，必须确保不同线程所访问的对象是同一对象，否则根本等于没锁；

　　（3）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结合起来使用就可以了，现在再增加一个线程，改代码如下：

using System;
using System.Collections.Generic;
using System.Text;

using System.Threading;

namespace ThreadLock
{
 class Program
 {
  #region variable
  Thread thread1 = null;
  Thread thread2 = null;
  Thread thread3 = 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));
   thread3 = new Thread(new ThreadStart(thread3Func));
  }
  public void RunThread()
  {
   thread1.Start();
   thread2.Start();
   thread3.Start();
  }
  private void thread1Func()
  {
   for (int count = 0; count < 10; count++)
   {
    lock (this)
    {
     mutex.WaitOne();
     TestFunc("Thread1 have run " + count.ToString() + " times");
     Thread.Sleep(30);
     mutex.ReleaseMutex();
    }
   }
  }
  private void thread2Func()
  {
   for (int count = 0; count < 10; count++)
   {
    lock (this)
    {
     mutex.WaitOne();
     TestFunc("Thread2 have run " + count.ToString() + " times");
     Thread.Sleep(100);
     mutex.ReleaseMutex();
    }
   }
  }
  private void thread3Func()
  {
   for (int count = 0; count < 10; count++)
   {
    lock (this)
    {
     mutex.WaitOne();
     TestFunc("Thread3 have run " + count.ToString() + " times");
     Thread.Sleep(100);
     mutex.ReleaseMutex();
    }
   }
  }
  private void TestFunc(string str)
  {
   Console.WriteLine("{0} {1}", str, System.DateTime.Now.Millisecond.ToString());
   Thread.Sleep(50);
  }

 }
}

运行结果如下：