雖然線程可以在一定程度上提高程序運行的效率，但也會產生一些副作用。讓我們先看看如下的代碼：  

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#線程中其他的同步技術。

【編輯推薦】

1. C#自定義特性介紹
2. C#內置特性介紹
3. 如何進行C#異常類的自定義
4. C#編程技巧七條
5. 預測C#與.NET的發展趨勢