C# lock

一. 为什么要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;
4. namespace Namespace1
5. {
6.     class C1
7.     {
8.         private bool deadlocked = true;
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.         }
24.         //所有线程都可以同时访问的方法
25.         public void DoNotLockMe()
26.         {
27.             Console.WriteLine("I am not locked :)");
28.         }
29.     }
31.     class Program
32.     {
33.         static void Main(string[] args)
34.         {
35.             C1 c1 = new C1();
37.             //在t1线程中调用LockMe，并将deadlock设为true（将出现死锁）
38.             Thread t1 = new Thread(c1.LockMe);
39.             t1.Start(true);
40.             Thread.Sleep(100);
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()都没有执行。

lock 是锁定lock里面的代码段，保证代码段不会被同时执行，而不是锁定lock（c1） 的c1，c1.DoNotLockMe()里面不执行到lock(this)里面的代码，所以不会有影响，至于为什么第一段代码中的方法不执行，是因为主程序那里有一个lock(c1),c1对象在前面已经被申请了互斥锁，所以主程序lock里面代码，需要等待支线程解开c1的互斥锁，所以一直不执行。如果把c1.DoNotLockMe()放在lock(c1)前面, 就会被执行

但是正常情况下都不会lock(this) 而以下面的形式

1. class C1
2.     {
3.         private bool deadlocked = true;
4.         private object locker = new object();
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.         }
20.         //所有线程都可以同时访问的方法
21.         public void DoNotLockMe()
22.         {
23.             Console.WriteLine("I am not locked :)");
24.         }
25.     }