多线程编程中的锁定(lock,Monitor)

多线程是一个非常好的技术，当然前提是我们正确地使用它。

在多线程编程中最难控制的就是对于同一个对象的并发访问（读写），如果不加以注意，那么就很有可能发生一些意料不到的情况。

为了防止或者说尽量减少并发问题，我们使用类似于数据库给数据加锁的机制来实现。

我们下面用例子来说明这个问题. 首先我们看一下标准的写法。我们用五个线程去做循环，他们都只做一件事情，修改一个公用变量（count）的值。

using System;
using System.Threading;
using System.IO;
namespace ConsoleApplication1
{
class Program
{
private static  int count = 0;
private static object syncroot = new object();
static void Main(string[] args)
{
StreamWriter sw = new
StreamWriter(DateTime.Now.ToLongTimeString().Replace(':','-') + ".log", true);
Console.SetOut(sw);
Thread thread1 = new Thread(new ThreadStart(SomeMethod));
Thread thread2 = new Thread(new ThreadStart(SomeMethod));
Thread thread3 = new Thread(new ThreadStart(SomeMethod));
Thread thread4 = new Thread(new ThreadStart(SomeMethod));
Thread thread5 = new Thread(new ThreadStart(SomeMethod));
thread1.Name = "Thread 1";
thread2.Name = "Thread 2";
thread3.Name = "Thread 3";
thread4.Name = "Thread 4";
thread5.Name = "Thread 5";
thread1.Start();
while (!thread1.IsAlive)
Thread.Sleep(10);
thread2.Start();
while (!thread2.IsAlive)
Thread.Sleep(100);
thread3.Start();
while (!thread3.IsAlive)
Thread.Sleep(100);
thread4.Start();
while (!thread4.IsAlive)
Thread.Sleep(100);
thread5.Start();
while (!thread5.IsAlive)
Thread.Sleep(100);
//分别启动了五个线程，做同样的事情
thread1.Join();
thread2.Join();
thread3.Join();
thread4.Join();
thread5.Join();
//让主线程等待这五个线程全部结束
sw.Close();
}
static void SomeMethod() {
Random rnd = new Random();
for (int i = 0; i < 10; i++)
{
int currentvalue = ++count;//给公用变量count递增1，并且将递增之后的结果赋给另外一个变量
Thread.Sleep(rnd.Next(100));//随机休眠0.1秒以内的时间
string output =
string.Format("当前线程:{0},当前值:{1},是否被别的线程篡改:{2}",
Thread.CurrentThread.Name, count, currentvalue != count);
Console.WriteLine(output);
}
}
}
}
我们来看最后的输出结果

当前线程:Thread 1,当前值:5,是否被别的线程篡改:True
当前线程:Thread 3,当前值:6,是否被别的线程篡改:True
当前线程:Thread 5,当前值:7,是否被别的线程篡改:True
当前线程:Thread 2,当前值:8,是否被别的线程篡改:True
当前线程:Thread 4,当前值:9,是否被别的线程篡改:True
当前线程:Thread 2,当前值:10,是否被别的线程篡改:True
当前线程:Thread 4,当前值:11,是否被别的线程篡改:True
当前线程:Thread 1,当前值:11,是否被别的线程篡改:True
当前线程:Thread 3,当前值:13,是否被别的线程篡改:True
当前线程:Thread 5,当前值:14,是否被别的线程篡改:True
当前线程:Thread 1,当前值:15,是否被别的线程篡改:True
当前线程:Thread 3,当前值:16,是否被别的线程篡改:True
当前线程:Thread 5,当前值:17,是否被别的线程篡改:True
当前线程:Thread 2,当前值:18,是否被别的线程篡改:True
当前线程:Thread 4,当前值:19,是否被别的线程篡改:True
当前线程:Thread 2,当前值:20,是否被别的线程篡改:True
当前线程:Thread 4,当前值:21,是否被别的线程篡改:True
当前线程:Thread 1,当前值:22,是否被别的线程篡改:True
当前线程:Thread 3,当前值:22,是否被别的线程篡改:True
当前线程:Thread 5,当前值:24,是否被别的线程篡改:True
当前线程:Thread 1,当前值:25,是否被别的线程篡改:True
当前线程:Thread 3,当前值:26,是否被别的线程篡改:True
当前线程:Thread 5,当前值:27,是否被别的线程篡改:True
当前线程:Thread 2,当前值:28,是否被别的线程篡改:True
当前线程:Thread 4,当前值:29,是否被别的线程篡改:True
当前线程:Thread 2,当前值:30,是否被别的线程篡改:True
当前线程:Thread 4,当前值:31,是否被别的线程篡改:True
当前线程:Thread 1,当前值:32,是否被别的线程篡改:True
当前线程:Thread 3,当前值:33,是否被别的线程篡改:True
当前线程:Thread 5,当前值:34,是否被别的线程篡改:True
当前线程:Thread 1,当前值:35,是否被别的线程篡改:True
当前线程:Thread 3,当前值:36,是否被别的线程篡改:True
当前线程:Thread 5,当前值:37,是否被别的线程篡改:True
当前线程:Thread 2,当前值:38,是否被别的线程篡改:True
当前线程:Thread 4,当前值:39,是否被别的线程篡改:True
当前线程:Thread 2,当前值:40,是否被别的线程篡改:True
当前线程:Thread 4,当前值:41,是否被别的线程篡改:True
当前线程:Thread 1,当前值:42,是否被别的线程篡改:True
当前线程:Thread 3,当前值:43,是否被别的线程篡改:True
当前线程:Thread 5,当前值:44,是否被别的线程篡改:True
当前线程:Thread 2,当前值:45,是否被别的线程篡改:True
当前线程:Thread 4,当前值:46,是否被别的线程篡改:True
当前线程:Thread 1,当前值:46,是否被别的线程篡改:True
当前线程:Thread 3,当前值:47,是否被别的线程篡改:True
当前线程:Thread 5,当前值:49,是否被别的线程篡改:True
当前线程:Thread 4,当前值:50,是否被别的线程篡改:True
当前线程:Thread 1,当前值:50,是否被别的线程篡改:True
当前线程:Thread 2,当前值:50,是否被别的线程篡改:True
当前线程:Thread 3,当前值:50,是否被别的线程篡改:True
当前线程:Thread 5,当前值:50,是否被别的线程篡改:False

让人震惊的是，只有最后一个输出的时候，才没有被篡改。就是说50次操作里面，只有一次也就是最后一次是保证了业务的要求的。而且你注意看每次书出来的当前值，很多是重复的。这是怎么回事呢？

其他的操作为什么会出现被别的线程篡改的情况呢？很简单，我们让它休眠了一会儿，在它休眠的时候，别的线程获得了访问权限，并进行了修改）。

注意，我们这里用休眠只是为了演示目的，现实生活中的例子就好比说，你先对一个变量进行了操作，然后又要进行其他的操作（这肯定也需要时间），然后最后还需要对之前那个变量进行读取。

那么，有没有什么方法可以防止这种问题出现吗？答案是肯定的，.NET内置对此进行支持。我们主要介绍两个方法

1.使用lock语句（该语法是C#专有的）

using System;
using System.Threading;
using System.IO;
namespace ConsoleApplication1
{
class Program
{
private static  int count = 0;
private static object syncroot = new object();
static void Main(string[] args)
{
StreamWriter sw = new
StreamWriter(DateTime.Now.ToLongTimeString().Replace(':','-') + ".log", true);
Console.SetOut(sw);
Thread thread1 = new Thread(new ThreadStart(SomeMethod));
Thread thread2 = new Thread(new ThreadStart(SomeMethod));
Thread thread3 = new Thread(new ThreadStart(SomeMethod));
Thread thread4 = new Thread(new ThreadStart(SomeMethod));
Thread thread5 = new Thread(new ThreadStart(SomeMethod));
thread1.Name = "Thread 1";
thread2.Name = "Thread 2";
thread3.Name = "Thread 3";
thread4.Name = "Thread 4";
thread5.Name = "Thread 5";
thread1.Start();
while (!thread1.IsAlive)
Thread.Sleep(10);
thread2.Start();
while (!thread2.IsAlive)
Thread.Sleep(100);
thread3.Start();
while (!thread3.IsAlive)
Thread.Sleep(100);
thread4.Start();
while (!thread4.IsAlive)
Thread.Sleep(100);
thread5.Start();
while (!thread5.IsAlive)
Thread.Sleep(100);
//分别启动了五个线程，做同样的事情
thread1.Join();
thread2.Join();
thread3.Join();
thread4.Join();
thread5.Join();
//让主线程等待这五个线程全部结束
sw.Close();
}
static void SomeMethod() {
Random rnd = new Random();
for (int i = 0; i < 10; i++)
{
lock (syncroot)
{
int currentvalue = ++count;
//给公用变量count递增1，并且将递增之后的结果赋给另外一个变量
Thread.Sleep(rnd.Next(100));
//随机休眠0.1秒以内的时间
string output =
string.Format("当前线程:{0},当前值:{1},是否被别的线程篡改:{2}",
Thread.CurrentThread.Name, count, currentvalue != count);
Console.WriteLine(output);
}
}
}
}
}

值得注意的是，lock语句里面的变量必须是引用类型，而不能是值类型。所以这里，我们不能lock(count)，而可以随便给一个object变量来进行lock，那么lock到底什么意思呢？就是在lock语句块里面的所有代码，所涉及到的变量都将被加锁，直到该语句块退出（就是说执行到lock语句块的那个"}" 后面的时候)

我们来看看输出结果

当前线程:Thread 1,当前值:1,是否被别的线程篡改:False
当前线程:Thread 2,当前值:2,是否被别的线程篡改:False
当前线程:Thread 3,当前值:3,是否被别的线程篡改:False
当前线程:Thread 4,当前值:4,是否被别的线程篡改:False
当前线程:Thread 5,当前值:5,是否被别的线程篡改:False
当前线程:Thread 1,当前值:6,是否被别的线程篡改:False
当前线程:Thread 2,当前值:7,是否被别的线程篡改:False
当前线程:Thread 3,当前值:8,是否被别的线程篡改:False
当前线程:Thread 4,当前值:9,是否被别的线程篡改:False
当前线程:Thread 5,当前值:10,是否被别的线程篡改:False
当前线程:Thread 1,当前值:11,是否被别的线程篡改:False
当前线程:Thread 2,当前值:12,是否被别的线程篡改:False
当前线程:Thread 3,当前值:13,是否被别的线程篡改:False
当前线程:Thread 4,当前值:14,是否被别的线程篡改:False
当前线程:Thread 5,当前值:15,是否被别的线程篡改:False
当前线程:Thread 1,当前值:16,是否被别的线程篡改:False
当前线程:Thread 2,当前值:17,是否被别的线程篡改:False
当前线程:Thread 3,当前值:18,是否被别的线程篡改:False
当前线程:Thread 4,当前值:19,是否被别的线程篡改:False
当前线程:Thread 5,当前值:20,是否被别的线程篡改:False
当前线程:Thread 1,当前值:21,是否被别的线程篡改:False
当前线程:Thread 2,当前值:22,是否被别的线程篡改:False
当前线程:Thread 3,当前值:23,是否被别的线程篡改:False
当前线程:Thread 4,当前值:24,是否被别的线程篡改:False
当前线程:Thread 5,当前值:25,是否被别的线程篡改:False
当前线程:Thread 1,当前值:26,是否被别的线程篡改:False
当前线程:Thread 2,当前值:27,是否被别的线程篡改:False
当前线程:Thread 3,当前值:28,是否被别的线程篡改:False
当前线程:Thread 4,当前值:29,是否被别的线程篡改:False
当前线程:Thread 5,当前值:30,是否被别的线程篡改:False
当前线程:Thread 1,当前值:31,是否被别的线程篡改:False
当前线程:Thread 2,当前值:32,是否被别的线程篡改:False
当前线程:Thread 3,当前值:33,是否被别的线程篡改:False
当前线程:Thread 4,当前值:34,是否被别的线程篡改:False
当前线程:Thread 5,当前值:35,是否被别的线程篡改:False
当前线程:Thread 1,当前值:36,是否被别的线程篡改:False
当前线程:Thread 2,当前值:37,是否被别的线程篡改:False
当前线程:Thread 3,当前值:38,是否被别的线程篡改:False
当前线程:Thread 4,当前值:39,是否被别的线程篡改:False
当前线程:Thread 5,当前值:40,是否被别的线程篡改:False
当前线程:Thread 1,当前值:41,是否被别的线程篡改:False
当前线程:Thread 2,当前值:42,是否被别的线程篡改:False
当前线程:Thread 3,当前值:43,是否被别的线程篡改:False
当前线程:Thread 4,当前值:44,是否被别的线程篡改:False
当前线程:Thread 5,当前值:45,是否被别的线程篡改:False
当前线程:Thread 1,当前值:46,是否被别的线程篡改:False
当前线程:Thread 2,当前值:47,是否被别的线程篡改:False
当前线程:Thread 3,当前值:48,是否被别的线程篡改:False
当前线程:Thread 4,当前值:49,是否被别的线程篡改:False
当前线程:Thread 5,当前值:50,是否被别的线程篡改:False

一点都不奇怪，现在输出的值是连续的，从1到50，而且没有任何一个值被篡改过了。为什么呢？它没有机会被篡改，因为在某个线程使用它的时候，它就被锁定了，别的线程必须等待这个锁被释放才可以继续进行更改。

所以，基于这样的原因，使用了lock之后，效率会稍微低一点。这是肯定的。

2.使用Monitor对象。刚才说到了lock语句是c#专用的，vb.net并没有该语法(vb.net确实也有一个Lock方法，但那个Lock是对文件进行锁定的），为了保证通用性，除了使用lock语句，还可以使用Moniter对象

using System;
using System.Threading;
using System.IO;
namespace ConsoleApplication1
{
class Program
{
private static  int count = 0;
private static object syncroot = new object();
static void Main(string[] args)
{
StreamWriter sw = new
StreamWriter(DateTime.Now.ToLongTimeString().Replace(':','-') + ".log", true);
Console.SetOut(sw);
Console.WriteLine("开始时间:" + DateTime.Now.ToLongTimeString());
Thread thread1 = new Thread(new ThreadStart(SomeMethod));
Thread thread2 = new Thread(new ThreadStart(SomeMethod));
Thread thread3 = new Thread(new ThreadStart(SomeMethod));
Thread thread4 = new Thread(new ThreadStart(SomeMethod));
Thread thread5 = new Thread(new ThreadStart(SomeMethod));
thread1.Name = "Thread 1";
thread2.Name = "Thread 2";
thread3.Name = "Thread 3";
thread4.Name = "Thread 4";
thread5.Name = "Thread 5";
thread1.Start();
while (!thread1.IsAlive)
Thread.Sleep(10);
thread2.Start();
while (!thread2.IsAlive)
Thread.Sleep(100);
thread3.Start();
while (!thread3.IsAlive)
Thread.Sleep(100);
thread4.Start();
while (!thread4.IsAlive)
Thread.Sleep(100);
thread5.Start();
while (!thread5.IsAlive)
Thread.Sleep(100);
//分别启动了五个线程，做同样的事情
thread1.Join();
thread2.Join();
thread3.Join();
thread4.Join();
thread5.Join();
//让主线程等待这五个线程全部结束
Console.WriteLine("结束时间：" + DateTime.Now.ToLongTimeString());
sw.Close();
}
static void SomeMethod() {
Random rnd = new Random();
for (int i = 0; i < 10; i++)
{
try
{
Monitor.Enter(syncroot);
int currentvalue = ++count;
//给公用变量count递增1，并且将递增之后的结果赋给另外一个变量
Thread.Sleep(rnd.Next(200));
//随机休眠0.2秒以内的时间
string output =
string.Format("当前线程:{0},当前值:{1},是否被别的线程篡改:{2}",
Thread.CurrentThread.Name, count, currentvalue != count);
Console.WriteLine(output);
}
catch { }
finally
{
Monitor.Exit(syncroot);
}
}
}
}
}

输出结果如下

当前线程:Thread 1,当前值:1,是否被别的线程篡改:False
当前线程:Thread 3,当前值:2,是否被别的线程篡改:False
当前线程:Thread 1,当前值:3,是否被别的线程篡改:False
当前线程:Thread 5,当前值:4,是否被别的线程篡改:False
当前线程:Thread 2,当前值:5,是否被别的线程篡改:False
当前线程:Thread 4,当前值:6,是否被别的线程篡改:False
当前线程:Thread 3,当前值:7,是否被别的线程篡改:False
当前线程:Thread 1,当前值:8,是否被别的线程篡改:False
当前线程:Thread 5,当前值:9,是否被别的线程篡改:False
当前线程:Thread 2,当前值:10,是否被别的线程篡改:False
当前线程:Thread 4,当前值:11,是否被别的线程篡改:False
当前线程:Thread 3,当前值:12,是否被别的线程篡改:False
当前线程:Thread 1,当前值:13,是否被别的线程篡改:False
当前线程:Thread 5,当前值:14,是否被别的线程篡改:False
当前线程:Thread 2,当前值:15,是否被别的线程篡改:False
当前线程:Thread 4,当前值:16,是否被别的线程篡改:False
当前线程:Thread 3,当前值:17,是否被别的线程篡改:False
当前线程:Thread 1,当前值:18,是否被别的线程篡改:False
当前线程:Thread 5,当前值:19,是否被别的线程篡改:False
当前线程:Thread 2,当前值:20,是否被别的线程篡改:False
当前线程:Thread 4,当前值:21,是否被别的线程篡改:False
当前线程:Thread 3,当前值:22,是否被别的线程篡改:False
当前线程:Thread 1,当前值:23,是否被别的线程篡改:False
当前线程:Thread 5,当前值:24,是否被别的线程篡改:False
当前线程:Thread 2,当前值:25,是否被别的线程篡改:False
当前线程:Thread 4,当前值:26,是否被别的线程篡改:False
当前线程:Thread 3,当前值:27,是否被别的线程篡改:False
当前线程:Thread 1,当前值:28,是否被别的线程篡改:False
当前线程:Thread 5,当前值:29,是否被别的线程篡改:False
当前线程:Thread 2,当前值:30,是否被别的线程篡改:False
当前线程:Thread 4,当前值:31,是否被别的线程篡改:False
当前线程:Thread 3,当前值:32,是否被别的线程篡改:False
当前线程:Thread 1,当前值:33,是否被别的线程篡改:False
当前线程:Thread 5,当前值:34,是否被别的线程篡改:False
当前线程:Thread 2,当前值:35,是否被别的线程篡改:False
当前线程:Thread 4,当前值:36,是否被别的线程篡改:False
当前线程:Thread 3,当前值:37,是否被别的线程篡改:False
当前线程:Thread 1,当前值:38,是否被别的线程篡改:False
当前线程:Thread 5,当前值:39,是否被别的线程篡改:False
当前线程:Thread 2,当前值:40,是否被别的线程篡改:False
当前线程:Thread 4,当前值:41,是否被别的线程篡改:False
当前线程:Thread 3,当前值:42,是否被别的线程篡改:False
当前线程:Thread 1,当前值:43,是否被别的线程篡改:False
当前线程:Thread 5,当前值:44,是否被别的线程篡改:False
当前线程:Thread 2,当前值:45,是否被别的线程篡改:False
当前线程:Thread 4,当前值:46,是否被别的线程篡改:False
当前线程:Thread 3,当前值:47,是否被别的线程篡改:False
当前线程:Thread 5,当前值:48,是否被别的线程篡改:False
当前线程:Thread 2,当前值:49,是否被别的线程篡改:False
当前线程:Thread 4,当前值:50,是否被别的线程篡改:False

一点都不意外，它的结论是和lock一样的。

那么，话说回来，lock与monitor到底有什么区别吗？答案是：没有啥区别。lock只是为了方便c#开发人员的一个快捷语法，实际上它在编译的时候会自动转换为monitor代码。所以，我们就经常强调，不同语言它们也许会有一些特殊的语法，但他们最终大多都是使用通用的.net framework 的功能来做某件事情。lock属于语言级别的概念，而monitor是属于.net framework 标准类库对象。

我们可以用ILDasm这个工具，来查看一下lock语句最后是怎么编译的

.method private hidebysig static void  SomeMethod() cil managed
{
// 代码大小       145 (0x91)
.maxstack  5
.locals init ([0] class [mscorlib]System.Random rnd,
[1] int32 i,
[2] int32 currentvalue,
[3] string output,
[4] object CS$2$0000,
[5] bool CS$4$0001)
IL_0000:  nop
IL_0001:  newobj     instance void [mscorlib]System.Random::.ctor()
IL_0006:  stloc.0
IL_0007:  ldc.i4.0
IL_0008:  stloc.1
IL_0009:  br.s       IL_0082
IL_000b:  nop
IL_000c:  ldsfld     object ConsoleApplication1.Program::syncroot
IL_0011:  dup
IL_0012:  stloc.s    CS$2$0000
IL_0014:  call       void [mscorlib]System.Threading.Monitor::Enter(object)
IL_0019:  nop
.try
{
IL_001a:  nop
IL_001b:  ldsfld     int32 ConsoleApplication1.Program::count
IL_0020:  ldc.i4.1
IL_0021:  add
IL_0022:  dup
IL_0023:  stsfld     int32 ConsoleApplication1.Program::count
IL_0028:  stloc.2
IL_0029:  ldloc.0
IL_002a:  ldc.i4     0xc8
IL_002f:  callvirt   instance int32 [mscorlib]System.Random::Next(int32)
IL_0034:  call       void [mscorlib]System.Threading.Thread::Sleep(int32)
IL_0039:  nop
IL_003a:  ldstr      bytearray (53 5F 4D 52 BF 7E 0B 7A 3A 00 7B 00 30 00 7D 00   // S_MR.~.z:.{.0.}.
2C 00 53 5F 4D 52 3C 50 3A 00 7B 00 31 00 7D 00   // ,.S_MR<P:.{.1.}.
2C 00 2F 66 26 54 AB 88 2B 52 84 76 BF 7E 0B 7A   // ,./f&T..+R.v.~.z
E1 7B 39 65 3A 00 7B 00 32 00 7D 00 )             // .{9e:.{.2.}.
IL_003f:  call       class [mscorlib]System.Threading.Thread 

[mscorlib]System.Threading.Thread::get_CurrentThread()
IL_0044:  callvirt   instance string [mscorlib]System.Threading.Thread::get_Name()
IL_0049:  ldsfld     int32 ConsoleApplication1.Program::count
IL_004e:  box        [mscorlib]System.Int32
IL_0053:  ldloc.2
IL_0054:  ldsfld     int32 ConsoleApplication1.Program::count
IL_0059:  ceq
IL_005b:  ldc.i4.0
IL_005c:  ceq
IL_005e:  box        [mscorlib]System.Boolean
IL_0063:  call       string [mscorlib]System.String::Format(string,
object,
object,
object)
IL_0068:  stloc.3
IL_0069:  ldloc.3
IL_006a:  call       void [mscorlib]System.Console::WriteLine(string)
IL_006f:  nop
IL_0070:  nop
IL_0071:  leave.s    IL_007c
}  // end .try
finally
{
IL_0073:  ldloc.s    CS$2$0000
IL_0075:  call       void [mscorlib]System.Threading.Monitor::Exit(object)
IL_007a:  nop
IL_007b:  endfinally
}  // end handler
IL_007c:  nop
IL_007d:  nop
IL_007e:  ldloc.1
IL_007f:  ldc.i4.1
IL_0080:  add
IL_0081:  stloc.1
IL_0082:  ldloc.1
IL_0083:  ldc.i4.s   10
IL_0085:  clt
IL_0087:  stloc.s    CS$4$0001
IL_0089:  ldloc.s    CS$4$0001
IL_008b:  brtrue     IL_000b
IL_0090:  ret
} // end of method Program::SomeMethod

太有意思了，它就是使用了try...catch...finally的方法，使用了monitor的Enter和Exit方法

那么，难道真的一点区别都没有吗？也不是啦，lock是一个最简单的monitor的实现，实际上monitor还有其他一些用法

例如：

Monitor.TryEnter ，这个方法可以指定等待的超时时间，如果指定的超时时间已经到了，仍然得不到锁，就返回false。否则，返回true. 如果把超时时间设置为0，则表示无限期等待（相当于Enter方法）

Monitor.Pulse 方法，通知等待队列中的线程锁定对象状态的更改。

Monitor.PulseAll 方法，通知所有的等待线程对象状态的更改。

注意，Pulse并不释放锁，只是给出一个信号灯，表示即将释放锁。其他等待的线程可以进行所谓的"就绪队列"。

Monitor.Wait 方法，释放对象上的锁并阻止当前线程，直到它重新获取该锁。