制作者：剑锋冷月 单位：无忧统计网,www.51stat.net
　　虽然线程可以在一定程度上提高程序运行的效率，但也会产生一些副作用。让我们先看看如下的代码：
　　classIncrement
　　{
　　　　privateintn=0;
　　　　privateintmax;
　　　　publicIncrement(intmax)
　　　　{
　　　　　　this.max=max;
　　　　}
　　　　publicintresult
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　returnn;
　　　　　　}
　　　　　　set
　　　　　　{
　　　　　　　　n=value;
　　　　　　}
　　　　}
　　　　publicvoidInc()
　　　　{　　　　　　
　　　　　　for(inti=0;i<max;i++)
　　　　　　{
　　　　　　　　n++;
　　　　　　}
　　　　}
　　}
　　classProgram
　　{
　　　　publicstaticvoidMain()
　　　　{
　　　　　　Incrementinc=newIncrement(10000);
　　　　　　Thread[]threads=newThread[30];
　　　　　　for(inti=0;i<threads.Length;i++)
　　　　　　{
　　　　　　　　threads[i]=newThread(inc.Inc);
　　　　　　　　threads[i].Start();
　　　　　　}
　　　　　　for(inti=0;i<threads.Length;i++)
　　　　　　{
　　　　　　　　threads[i].Join();　//等待30个线程都执行完
　　　　　　}
　　　　　　Console.WriteLine(inc.result);　//输出n的值
　　　　}
　　}
　　上面的程序的基本功能是使用Increment的Inc方法为n递增max，所不同的是，将在Main方法中启动30个线程同时执行Inc方法。在本例中max的值是10000（通过Increment的构造方法传入）。读者可以运行一下这个程序，正常的结果应该是300000，但通常不会得到这个结果，一般获得的结果都比300000小。其中的原因就是Inc方法中的n++上，虽然从表面上看，n++只是一条简单的自增语言，但从底层分析，n++的IL代码如下：
　　ldsfld// 获得n的初始值，并压到方法栈中
　　ldc.i4.1// 将1压到方法栈中
　　add// 从方法栈中弹出最顶端的两个值，相加，然后将结果保存在方法栈中
　　stfld// 从当前方法栈中弹出一个值，并更新类字段n
　　对于上面每一条IL语句是线程安全的，但是n++这条C#语句需要上面的四步才能完成，因此，n++这条语句并不是线程安全的。只要在执行stfld指令之前的任何一步由于其他线程获得CPU而中断，那么就会出现所谓的“脏”数据。
　　假设n的初始值为0， 在thread1在执行完ldc.i4.1后被thread2中断（add指令并未执行），这时thread2获得的n的初始值仍然是0，假设thread2顺利执行完，那么这时n的值已经是1了，当thread2执行完后，thread1继续执行add指令，并且thread1也顺利执行完，这时，在thread1中的执行结果n仍然是1。因此，这也就出现了调用两次n++，n仍然为1的情况。要解决这个问题的方法也很容易想到，就是让上述四条IL语句要不都不执行，要执行就都执行完，这有点事务处理的意思。
　　在C#中解决这个问题的技术叫同步。同步的本质就是为某一个代码块加锁，使其成为一个整体，共同进退。最简单的是使用lock为代码块加锁。这个语句在前几讲已经多次使用过了。lock语句可以锁定任何的对象，如果锁定的是类成员，直接使用lock(obj)的形式即可，如果锁定的是静态成员，可以把锁主在object类型上，代码如下：
lock(typeof(StaticClass))
{
　 ... ...
}
　　对于Increment类，我们可以锁定n++，也可以锁定Inc方法，如锁定n++的Increment类的代码如下：
　　classIncrement
　　{
　　　　privateintn=0;
　　　　privateintmax;
　　　　privateObjectlockN=newObject();
　　　　publicIncrement(intmax)
　　　　{
　　　　　　this.max=max;
　　　　}
　　　　publicintresult
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　returnn;
　　　　　　}
　　　　　　set
　　　　　　{
　　　　　　　　n=value;
　　　　　　}
　　　　}
　　　　privatevoidIncN()
　　　　{
　　　　　　lock(lockN)
　　　　　　{
　　　　　　　　n++;
　　　　　　}
　　　　}
　　　　publicvoidInc()
　　　　{
　　　　　　for(inti=0;i<max;i++)
　　　　　　{
　　　　　　　　　IncN();
　　　　　　}　　　　　
　　　　}
　　}
　　也可以直接将如下的代码放到for循环中取代调用IncN方法，
lock(lockN)
{
　　n++;
}
　　或者直接将Inc方法锁住，代码如下：
　　　　publicvoidInc()
　　　　{
　　　　　　lock(lockN)
　　　　　　{
　　　　　　　　for(inti=0;i<max;i++)
　　　　　　　　{
　　　　　　　　　　n++;
　　　　　　　　}
　　　　　　}
　　　　}
　　但笔者并不建议直接将Inc锁住，因为这样就和单线程没什么区别了，虽然可以避免出现读脏数据的情况，但却牺牲的效率。
　　从本例分析得知，产生问题的原因就是因为n++不是原子操作。而在.net framework中提供了一个Interlocked类，可以使n++变成原子操作。Interlocked有一些方法，可以保证对变量的操作是原子的，如Increment方法保证n++的操作是原子的，Decrement方法保证n--的操作是原子的，Exchange方法保证为变量赋值的操作是原子的。因此，可以使用Increment方法来替换n++，代码如下：
publicvoidInc()
{
　　for(inti=0;i<max;i++)
　　{
　　　　Interlocked.Increment(refn);
　　}
}
　　任何事物都具有两面性，同步技术也不例外，在某些情况下，可以由于两个线程互相锁定某些对象而造成死锁（就是两个线程互相等待对方释放对象）。这就象有两个学生晚上在复习功课，他们都希望学习能超过对方，而且他们都很累了，但是谁也不肯先休息，是都在盯着对方屋里的灯，期望着对方休息后。自己才休息。但却谁也不肯先关灯，所以他们就只有这样耗到天亮了。当然，解决这个问题的方法有两个，第一个就是其中一个学生或两个学生根本就不关心对方是否先睡觉，自己学累了就直接关灯了。当然，另外一个方法就有点暴力了，就是到点就直接断电，那谁也别学了（这也相当于线程中断，不过不到万不得以时最好别用这招）。
　　让我们先举一个线程死锁的例子，代码如下：
　　classProgram
　　{
　　　　privatestaticObjectobjA=newObject();
　　　　privatestaticObjectobjB=newObject();
　　　　publicstaticvoidLockA()
　　　　{
　　　　　　lock(objA)
　　　　　　{
　　　　　　　　Thread.Sleep(1000);
　　　　　　　　lock(objB)
　　　　　　　　{
　　　　　　　　}
　　　　　　}
　　　　　　Console.WriteLine("LockA");
　　　　}
　　　　publicstaticvoidLockB()
　　　　{
　　　　　　lock(objB)
　　　　　　{
　　　　　　　　Thread.Sleep(2000);
　　　　　　　　lock(objA)
　　　　　　　　{
　　　　　　　　}
　　　　　　}
　　　　　　Console.WriteLine("LockB");
　　　　}
　　　　publicstaticvoidMain()
　　　　{
　　　　　　ThreadthreadA=newThread(LockA);
　　　　　　ThreadthreadB=newThread(LockB);
　　　　　　threadA.Start();
　　　　　　threadB.Start();
　　　　}
　　}
　　在上面的代码中，LockA方法会在当前线程中执行完Lock(objA)后延迟1秒，而LockB方法会在执行完lock(objB)后延迟2秒，一般LockA会先执行lock(objB），但这时objB已经被LockB锁住了，而且LockB还在延迟（2秒还没到）。在这时，LockA已经将objA和objB都锁上了，当LockB执行到lock(objA)时，由于objA已经被锁上，因此，LockB就被阻塞了。而LockA在执行到lock(objB）时，由于这时LockA还在延迟，因此，objB也被锁住了。LockA和LockB也就相当于上述的两个学生，互相等待对方关灯，但谁也不肯先关灯，所以就死锁了。如果采用第一种方法非常简单，就是保持被锁定的多个对象的顺序，如将LockB方法的锁定顺序换一下，代码如下：
publicstaticvoidLockB()
{
　　lock(objA)
　　{
　　　　Thread.Sleep(2000);
　　　　　lock(objB)
　　　　　{
　　　　　}
　　}
　　Console.WriteLine("LockB");
}
　　或是将LockA方法也改一下，先锁objB，再锁objA。
　　当然，也可以采用暴力一点的方法，当发现一些线程长时间没反应时，可以使用Abort方法强行中断它们。代码如下：
publicstaticvoidMain()
{
　　ThreadthreadA=newThread(LockA);
　　ThreadthreadB=newThread(LockB);
　　threadA.Start();
　　threadB.Start();
　　Thread.Sleep(4000);
　　threadA.Abort();
　　threadB.Abort();
　　Console.WriteLine("线程全部结束");
}
　　在后面的文章中将讲解C#中其他的同步技术。
　　文章来源:http://www.cnblogs.com/nokiaguy/archive/2008/07/25/1251756.html
　　ldsfld// 获得n的初始值，并压到方法栈中
　　ldc.i4.1// 将1压到方法栈中
　　add// 从方法栈中弹出最顶端的两个值，相加，然后将结果保存在方法栈中
　　stfld// 从当前方法栈中弹出一个值，并更新类字段n
　　对于上面每一条IL语句是线程安全的，但是n++这条C#语句需要上面的四步才能完成，因此，n++这条语句并不是线程安全的。只要在执行stfld指令之前的任何一步由于其他线程获得CPU而中断，那么就会出现所谓的“脏”数据。
　　假设n的初始值为0， 在thread1在执行完ldc.i4.1后被thread2中断（add指令并未执行），这时thread2获得的n的初始值仍然是0，假设thread2顺利执行完，那么这时n的值已经是1了，当thread2执行完后，thread1继续执行add指令，并且thread1也顺利执行完，这时，在thread1中的执行结果n仍然是1。因此，这也就出现了调用两次n++，n仍然为1的情况。要解决这个问题的方法也很容易想到，就是让上述四条IL语句要不都不执行，要执行就都执行完，这有点事务处理的意思。
　　在C#中解决这个问题的技术叫同步。同步的本质就是为某一个代码块加锁，使其成为一个整体，共同进退。最简单的是使用lock为代码块加锁。这个语句在前几讲已经多次使用过了。lock语句可以锁定任何的对象，如果锁定的是类成员，直接使用lock(obj)的形式即可，如果锁定的是静态成员，可以把锁主在object类型上，代码如下：
lock(typeof(StaticClass))
{
　 ... ...
}
　　对于Increment类，我们可以锁定n++，也可以锁定Inc方法，如锁定n++的Increment类的代码如下：
　　classIncrement
　　{
　　　　privateintn=0;
　　　　privateintmax;
　　　　privateObjectlockN=newObject();
　　　　publicIncrement(intmax)
　　　　{
　　　　　　this.max=max;
　　　　}
　　　　publicintresult
　　　　{
　　　　　　get
　　　　　　{
　　　　　　　　returnn;
　　　　　　}
　　　　　　set
　　　　　　{
　　　　　　　　n=value;
　　　　　　}
　　　　}
　　　　privatevoidIncN()
　　　　{
　　　　　　lock(lockN)
　　　　　　{
　　　　　　　　n++;
　　　　　　}
　　　　}
　　　　publicvoidInc()
　　　　{
　　　　　　for(inti=0;i<max;i++)
　　　　　　{
　　　　　　　　　IncN();
　　　　　　}　　　　　
　　　　}
　　}