使用lock(this)需要谨慎

原文： http://blog.csdn.net/msdnwoo/article/details/50413614

lock(this) 容易出错，比如对象有多个实例，如果成员函数用了lock(this), 外部又用了lock(obj), 会造成死锁。

lock(this) 导致锁住整个对象，当执行不需要锁的函数时也被锁了

. 为什么要lock，lock了什么？

当我们使用线程的时候，效率最高的方式当然是异步，即各个线程同时运行，其间不相互依赖和等待。但当不同的线程都需要访问某个资源的时候，就需要同步机制了，也就是说当对同一个资源进行读写的时候，我们要使该资源在同一时刻只能被一个线程操作，以确保每个操作都是有效即时的，也即保证其操作的原子性。lock是C#中最常用的同步方式，格式为lock(objectA){codeB}。

lock(objectA){codeB}看似简单，实际上有三个意思，这对于适当地使用它至关重要：

1.objectA被lock了吗？没有则由我来lock，否则一直等待，直至objectA被释放。

2.lock以后在执行codeB的期间其他线程不能调用codeB，也不能使用objectA。

3.执行完codeB之后释放objectA，并且codeB可以被其他线程访问。

二.lock(this)怎么了？

我们看一个例子：

[csharp]  view plain  copy

 print ?

1. using System;  
2. using System.Threading;  
3.   
4. namespace Namespace1  
5. {  
6.     class C1  
7.      {  
8.         private bool deadlocked=true;  
9.   
10.         //这个方法用到了lock，我们希望lock的代码在同一时刻只能由一个线程访问  
11.         public void LockMe(object o)  
12.          {  
13.             lock (this)  
14.              {  
15.                 while(deadlocked)  
16.                  {  
17.                      deadlocked = (bool)o;  
18.                      Console.WriteLine("Foo: I am locked :(");  
19.                      Thread.Sleep(500);  
20.                  }  
21.              }  
22.          }  
23.   
24.         //所有线程都可以同时访问的方法  
25.         publicvoid DoNotLockMe()  
26.          {  
27.              Console.WriteLine("I am not locked :)");  
28.          }  
29.      }  
30.   
31.     class Program  
32.      {  
33.         staticvoid Main(string[] args)  
34.          {  
35.              C1 c1 =new C1();  
36.   
37.             //在t1线程中调用LockMe，并将deadlock设为true（将出现死锁）  
38.              Thread t1=new Thread(c1.LockMe);  
39.              t1.Start(true);  
40.              Thread.Sleep(100);  
41.   
42.             //在主线程中lock c1  
43.             lock (c1)  
44.              {  
45.                 //调用没有被lock的方法  
46.                  c1.DoNotLockMe();  
47.                 //调用被lock的方法，并试图将deadlock解除  
48.                  c1.LockMe(false);  
49.              }  
50.          }  
51.      }  

在t1线程中， LockMe调用了lock(this),也就是Main函数中的c1，这时候在主线程中调用lock(c1)时，必须要等待t1中的lock块执行完毕之后才能访问c1，即所有c1相关的操作都无法完成，于是我们看到连c1.DoNotLockMe()都没有执行。

把C1的代码稍作改动：

[csharp]  view plain  copy

 print ?

1. class C1  
2.  {  
3.     privatebool deadlocked=true;  
4.     privateobject locker=newobject();  
5.   
6.     //这个方法用到了lock，我们希望lock的代码在同一时刻只能由一个线程访问  
7.     public void LockMe(object o)  
8.      {  
9.         lock (locker)  
10.          {  
11.             while(deadlocked)  
12.              {  
13.                  deadlocked = (bool)o;  
14.                  Console.WriteLine("Foo: I am locked :(");  
15.                  Thread.Sleep(500);  
16.              }  
17.          }  
18.      }  
19.   
20.     //所有线程都可以同时访问的方法  
21.     public void DoNotLockMe()  
22.      {  
23.          Console.WriteLine("I am not locked :)");  
24.      }  
25.  }  

这次我们使用一个私有成员作为锁定变量(locker)，在LockMe中仅仅锁定这个私有locker，而不是整个对象。这时候重新运行程序，可以看到虽然t1出现了死锁，DoNotLockMe()仍然可以由主线程访问；LockMe()依然不能访问，原因是其中锁定的locker还没有被t1释放。

关键点：

1.lock(this)的缺点就是在一个线程锁定某对象之后导致整个对象无法被其他线程访问。

2.锁定的不仅仅是lock段里的代码，锁本身也是线程安全的。

3.我们应该使用不影响其他操作的私有对象作为locker。

4.在使用lock的时候，被lock的对象(locker)一定要是引用类型的，如果是值类型，将导致每次lock的时候都会将该对象装箱为一个新的引用对象(事实上如果使用值类型，c#编译器在编译时会给出个错误）