一. 为什么要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)怎么了？


我们看一个例子：

  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.         public void DoNotLockMe()
  26.         {
  27.             Console.WriteLine("I am not locked :)");
  28.         }
  29.     }
  30.  
  31.     class Program
  32.     {
  33.         static void 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的代码稍作改动：

  1.     class C1
  2.     {
  3.         private bool deadlocked = true;
  4.         private object locker = new object();
  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)的缺点就是在一个线程（例如本例的t1）通过执行该类的某个使用"lock(this)"的方法(例如本例的LockMe())锁定 某对象之后, 导致整个对象无法被其他线程(例如本例的主线程)访问 - 因为很多人在其他线程(例如本例的主线程)中使用该类的时候会使用类似lock(c1)的代码。


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

安全

的。


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


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