线程中的 Lock

一、Lock定义

    lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。

     在多线程中，每个线程都有自己的资源，但是代码区是共享的，即每个线程都可以执行相同的函数。这可能带来的问题就是几个线程同时执行一个函数，导致数据的混乱，产生不可预料的结果，因此我们必须避免这种情况的发生。

    而在.NET中最好了解一下进程、应用域和线程的概念，因为Lock是针对线程一级的，而在.NET中应用域是否会对Lock起隔离作用，我的猜想是，即不在同一应用域中的线程无法通过Lock来中断；另外也最好能了解一下数据段、代码段、堆、栈等概念。

    在C# lock关键字定义如下：

    lock（expression） statement_block，其中expression代表你希望跟踪的对象，通常是对象引用。

    如果你想保护一个类的实例，一般地，你可以使用this；如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可以了。

而statement_block就是互斥段的代码，这段代码在一个时刻内只可能被一个线程执行。

二、简单例子

1.   using System;
2.   using System.Collections;
3.   using System.Collections.Generic;
4.   using System.Threading;
5.   namespace ConsoleApplication1
6.   {
7.   class Program
8.   {
9.   static void Main(string[] args)
10.   {
11.   Thread thread1 = new Thread(new ThreadStart(ThreadStart1));
12.   thread1.Name = "Thread1";
13.   Thread thread2 = new Thread(new ThreadStart(ThreadStart2));
14.   thread2.Name = "Thread2";
15.   Thread thread3 = new Thread(new ThreadStart(ThreadStart3));
16.   thread3.Name = "Thread3";
17.   thread1.Start();
18.   thread2.Start();
19.   thread3.Start();
20.   Console.ReadKey();
21.   }
22.   static object _object = new object();
23.   static void Done(int millisecondsTimeout)
24.   {
25.   Console.WriteLine(string.Format("{0} -> {1}.Start", DateTime.Now.ToString("HH:mm:ss"), Thread.CurrentThread.Name));
26.   //下边代码段同一时间只能由一个线程在执行
27.   lock (_object)
28.   {
29.   Console.WriteLine(string.Format("{0} -> {1}进入锁定区域.", DateTime.Now.ToString("HH:mm:ss"), Thread.CurrentThread.Name));
30.   Thread.Sleep(millisecondsTimeout);
31.   Console.WriteLine(string.Format("{0} -> {1}退出锁定区域.", DateTime.Now.ToString("HH:mm:ss"), Thread.CurrentThread.Name));
32.   }
33.   }
34.   static void ThreadStart1()
35.   {
36.   Done(5000);
37.   }
38.   static void ThreadStart2()
39.   {
40.   Done(3000);
41.   }
42.   static void ThreadStart2()
43.   {
44.   Done(1000);
45.   }
46.   }
47.   }

三、简单解释一下执行过程

先来看看执行过程，代码示例如下：

        private static object  ojb = new object();

        lock(obj)

        {

                 //锁定运行的代码段

        }
  假设线程A先执行，线程B稍微慢一点。线程A执行到lock语句，判断obj是否已申请了互斥锁，判断依据是逐个与已存在的锁进行object.ReferenceEquals比较(此处未加证实)，如果不存在，则申请一个新的互斥锁，这时线程A进入lock里面了。

这时假设线程B启动了，而线程A还未执行完lock里面的代码。线程B执行到lock语句，检查到obj已经申请了互斥锁，于是等待;直到线程A执行完毕，释放互斥锁，线程B才能申请新的互斥锁并执行lock里面的代码。