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能够保证被锁定对象能够被不同线程同步访问。
在多线程中,为了使数据保持一致性必须要对数据或是访问数据的函数加锁,在数据库中这是很常见的,但是在程序中由于大部分都是单线程的程序,所以没有加锁的必要,但是在多线程中,为了保持数据的同步,一定要加锁,好在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);
}
}
}
运行结果如下:
![](https://p-blog.csdn.net/images/p_blog_csdn_net/tjvictor/49f6572e7070480bbb0b0c0ae529beaa.png)
可以看出如果不加锁的话,这两个线程基本上是按照各自的时间间隔+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结果如下:
![](https://p-blog.csdn.net/images/p_blog_csdn_net/tjvictor/9100c299531d43e7a35aeffac7b267f1.png)
让我们分析一下结果,同样从第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);
}
运行结果如下:
![](https://p-blog.csdn.net/images/p_blog_csdn_net/tjvictor/672cde0b62ba48b6a217f3131111c545.png)
可以看出,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();
}
}
}
![](https://p-blog.csdn.net/images/p_blog_csdn_net/tjvictor/c84967ceac8c454b8ff81e212d526a50.png)
from:http://www.cnblogs.com/guozhiming2003/archive/2008/09/16/1291953.html