虽然线程可以在一定程度上提高程序运行的效率，但也会产生一些副作用。
让我们先看看如下的代码：
对于
Increment
类，我们可以锁定
n++
，也可以锁定
Inc
方法，如锁定
n++
的
Increment
类的代码如下：
也可以直接将如下的代码放到for 循环中取代调用IncN 方法，
或者直接将 Inc 方法锁住，代码如下：
class
Increment
{
private int n = 0 ;
private int max;
public Increment( int max)
{
this .max = max;
}
public int result
{
get
{
return n;
}
set
{
n = value;
}
}
public void Inc()
{
for ( int i = 0 ; i < max; i ++ )
{
n ++ ;
}
}
}
class Program
{
public static void Main()
{
Increment inc = new Increment( 10000 );
Thread[] threads = new Thread[ 30 ];
for ( int i = 0 ; i < threads.Length; i ++ )
{
threads[i] = new Thread(inc.Inc);
threads[i].Start();
}
for ( int i = 0 ; i < threads.Length; i ++ )
{
threads[i].Join(); // 等待30个线程都执行完
}
Console.WriteLine(inc.result); // 输出n的值
{
private int n = 0 ;
private int max;
public Increment( int max)
{
this .max = max;
}
public int result
{
get
{
return n;
}
set
{
n = value;
}
}
public void Inc()
{
for ( int i = 0 ; i < max; i ++ )
{
n ++ ;
}
}
}
class Program
{
public static void Main()
{
Increment inc = new Increment( 10000 );
Thread[] threads = new Thread[ 30 ];
for ( int i = 0 ; i < threads.Length; i ++ )
{
threads[i] = new Thread(inc.Inc);
threads[i].Start();
}
for ( int i = 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 的初始值，并压到方法栈中
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))
{
... ...
}
class
Increment
{
private int n = 0 ;
private int max;
private Object lockN = new Object();
public Increment( int max)
{
this .max = max;
}
public int result
{
get
{
return n;
}
set
{
n = value;
}
}
private void IncN()
{
lock (lockN)
{
n ++ ;
}
}
public void Inc()
{
for ( int i = 0 ; i < max; i ++ )
{
IncN();
}
}
}
{
private int n = 0 ;
private int max;
private Object lockN = new Object();
public Increment( int max)
{
this .max = max;
}
public int result
{
get
{
return n;
}
set
{
n = value;
}
}
private void IncN()
{
lock (lockN)
{
n ++ ;
}
}
public void Inc()
{
for ( int i = 0 ; i < max; i ++ )
{
IncN();
}
}
}
也可以直接将如下的代码放到for 循环中取代调用IncN 方法，
lock
(lockN)
{
n ++ ;
}
{
n ++ ;
}
或者直接将 Inc 方法锁住，代码如下：
public
void
Inc()
{
lock (lockN)
{
for ( int i = 0 ; i < max; i ++ )
{
n ++ ;
}
}
}
{
lock (lockN)
{
for ( int i = 0 ; i < max; i ++ )
{
n ++ ;
}
}
}
但笔者并不建议直接将Inc
锁住，因为这样就和单线程没什么区别了，虽然可以避免出现读脏数据的情况，但却牺牲的效率。
从本例分析得知，产生问题的原因就是因为n++
不是原子操作。而在.net framework
中提供了一个Interlocked
类，可以使n++
变成原子操作。Interlocked
有一些方法，可以保证对变量的操作是原子的，如Increment
方法保证n++
的操作是原子的，Decrement
方法保证n--
的操作是原子的，Exchange
方法保证为变量赋值的操作是原子的。因此，可以使用Increment
方法来替换n++
，代码如下：
public
void
Inc()
{
for ( int i = 0 ; i < max; i ++ )
{
Interlocked.Increment( ref n);
}
}
{
for ( int i = 0 ; i < max; i ++ )
{
Interlocked.Increment( ref n);
}
}
任何事物都具有两面性，同步技术也不例外，在某些情况下，可以由于两个线程互相锁定某些对象而造成死锁（就是两个线程互相等待对方释放对象）。这就象有两个学生晚上在复习功课，他们都希望学习能超过对方，而且他们都很累了，但是谁也不肯先休息，是都在盯着对方屋里的灯，期望着对方休息后。自己才休息。但却谁也不肯先关灯，所以他们就只有这样耗到天亮了。当然，解决这个问题的方法有两个，第一个就是其中一个学生或两个学生根本就不关心对方是否先睡觉，自己学累了就直接关灯了。当然，另外一个方法就有点暴力了，就是到点就直接断电，那谁也别学了（这也相当于线程中断，不过不到万不得以时最好别用这招）。
让我们先举一个线程死锁的例子，代码如下：
class
Program
{
private static Object objA = new Object();
private static Object objB = new Object();
public static void LockA()
{
lock (objA)
{
Thread.Sleep( 1000 );
lock (objB)
{
}
}
Console.WriteLine( " LockA " );
}
public static void LockB()
{
lock (objB)
{
Thread.Sleep( 2000 );
lock (objA)
{
}
}
Console.WriteLine( " LockB " );
}
public static void Main()
{
Thread threadA = new Thread(LockA);
Thread threadB = new Thread(LockB);
threadA.Start();
threadB.Start();
}
}
{
private static Object objA = new Object();
private static Object objB = new Object();
public static void LockA()
{
lock (objA)
{
Thread.Sleep( 1000 );
lock (objB)
{
}
}
Console.WriteLine( " LockA " );
}
public static void LockB()
{
lock (objB)
{
Thread.Sleep( 2000 );
lock (objA)
{
}
}
Console.WriteLine( " LockB " );
}
public static void Main()
{
Thread threadA = new Thread(LockA);
Thread threadB = new Thread(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
方法的锁定顺序换一下，代码如下：
public
static
void
LockB()
{
lock (objA)
{
Thread.Sleep( 2000 );
lock (objB)
{
}
}
Console.WriteLine( " LockB " );
}
{
lock (objA)
{
Thread.Sleep( 2000 );
lock (objB)
{
}
}
Console.WriteLine( " LockB " );
}
或是将LockA
方法也改一下，先锁objB
，再锁objA
。
当然，也可以采用暴力一点的方法，当发现一些线程长时间没反应时，可以使用
Abort
方法强行中断它们。代码如下：
public
static
void
Main()
{
Thread threadA = new Thread(LockA);
Thread threadB = new Thread(LockB);
threadA.Start();
threadB.Start();
Thread.Sleep( 4000 );
threadA.Abort();
threadB.Abort();
Console.WriteLine( " 线程全部结束 " );
}
{
Thread threadA = new Thread(LockA);
Thread threadB = new Thread(LockB);
threadA.Start();
threadB.Start();
Thread.Sleep( 4000 );
threadA.Abort();
threadB.Abort();
Console.WriteLine( " 线程全部结束 " );
}
在后面的文章中将讲解C#
中其他的同步技术。
本文转自 androidguy 51CTO博客，原文链接：http://blog.51cto.com/androidguy/216661，如需转载请自行联系原作者
