【原創】C#執行緒系列講座(4)：同步與死鎖

銀河使者發表於2008-07-26
C#執行緒
本文為原創，如需轉載，請註明作者和出處，謝謝！

雖然執行緒可以在一定程度上提高程式執行的效率，但也會產生一些副作用。讓我們先看看如下的程式碼：
<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gt    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類的程式碼如下：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gt    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方法，


<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gt lock (lockN)
 {
     n++;
 }

或者直接將Inc方法鎖住，程式碼如下：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gt        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++，程式碼如下：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gtpublic void Inc()
{
    for (int i = 0; i < max; i++)
    {
        Interlocked.Increment(ref n);
    }
}


    任何事物都具有兩面性，同步技術也不例外，在 某些情況下，可以由於兩個執行緒互相鎖定某些物件而造成死鎖（就是兩個執行緒互相等待對方釋放物件）。這就象有兩個學生晚上在複習功課，他們都希望學習能超過 對方，而且他們都很累了，但是誰也不肯先休息，是都在盯著對方屋裡的燈，期望著對方休息後。自己才休息。但卻誰也不肯先關燈，所以他們就只有這樣耗到天亮 了。當然，解決這個問題的方法有兩個，第一個就是其中一個學生或兩個學生根本就不關心對方是否先睡覺，自己學累了就直接關燈了。當然，另外一個方法就有點 暴力了，就是到點就直接斷電，那誰也別學了（這也相當於執行緒中斷，不過不到萬不得以時最好別用這招）。

    讓我們先舉一個執行緒死鎖的例子，程式碼如下：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gt    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方法的鎖定順序換一下，程式碼如下：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--&gtpublic static void LockB()
{
    lock (objA)
    {
         Thread.Sleep(2000);
          lock (objB)
          {
          }
    }
    Console.WriteLine("LockB");
}


    或是將LockA方法也改一下，先鎖objB，再鎖objA。

    當然，也可以採用暴力一點的方法，當發現一些執行緒長時間沒反應時，可以使用Abort方法強行中斷它們。程式碼如下：
<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

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


來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/12921506/viewspace-410234/，如需轉載，請註明出處，否則將追究法律責任。

相關文章