虽然线程可以在一定程度上提高程序运行的效率，但也会产生一些副作用。让我们先看看如下的代码：
     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的值
        }
    }

    上面的程序的基本功能是使用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 类的代码如下：

     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();
            }           
        }
    }

    也可以直接将如下的代码放到for 循环中取代调用IncN 方法，

  lock  (lockN)
 {
     n ++ ;
 }

或者直接将Inc 方法锁住，代码如下：

         public   void  Inc()
        {
             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);
    }
}

    任何事物都具有两面性，同步技术也不例外，在某些情况下，可以由于两个线程互相锁定某些对象而造成死锁（就是两个线程互相等待对方释放对象）。这就象有两个学生晚上在复习功课，他们都希望学习能超过对方，而且他们都很累了，但是谁也不肯先休息，是都在盯着对方屋里的灯，期望着对方休息后。自己才休息。但却谁也不肯先关灯，所以他们就只有这样耗到天亮了。当然，解决这个问题的方法有两个，第一个就是其中一个学生或两个学生根本就不关心对方是否先睡觉，自己学累了就直接关灯了。当然，另外一个方法就有点暴力了，就是到点就直接断电，那谁也别学了（这也相当于线程中断，不过不到万不得以时最好别用这招）。
    让我们先举一个线程死锁的例子，代码如下：
     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();
        }
    }

    在上面的代码中，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 " );
}

    或是将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( " 线程全部结束 " );
}

    在后面的文章中将讲解C# 中其他的同步技术。