第二章，什么時候需要鎖

看看以下會不會產生死鎖：

public class A
    {
        private object obj = new object();
        public void Test(int i)
        {
            lock (obj)
            {
                if (i>10)
                {
                    i--;
                    Test(i);
                }
                else
                {
                    Console.WriteLine(i);
                }
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.Test(15);
            Console.ReadKey();
        }
    }

 

你的答案是會產生死鎖嗎？可以理解，因為也許你以前一直以為外層遞歸被鎖住后，不允許在訪問里邊的代碼快，而由於遞歸，有需要等待外層遞歸解鎖，所以由此造成死鎖，現在才知道這種理解是錯誤的；結果是永遠不會出現死鎖，因為lock的本質是對於不同的線程來說的，或者這個所的所有權已經歸該現成所有，它可以任意使用該鎖；

說道這里又想多說一點，假如另一個線程在另一個函數里操作同一個obj，這是obj可以被訪問嗎在鎖釋放之前，如下代碼：

public class Test
    {
        string name = "Empty";

        public Test()
        {
 
        }

        public string Name
        {
            get
            {
                return this.name;
            }
            set
            {
                this.name = value;
            }
        }
    }

    public class A
    {
        Test test = new Test();

        public void OneMethod()
        {
            lock (this.test)
            {
                Console.WriteLine("one thread come in,sleep for 10 seconds");
                Console.WriteLine(test.Name);
                Thread.Sleep(10000);//如果第二個線程可以在鎖住期間可以對test對象操作，那么線程二應該在10000毫秒之內已經輸出
                test.Name = "One thread output";
                Console.WriteLine(test.Name);
            }
        }

        public void TwoMethod()
        {
            Thread.Sleep(100);//為了確保第一個線程先鎖住后在操作test對象
            Console.WriteLine("two thread come in");//假如由於線程一鎖住test對象而不能對test操作的話，那么要等待10000毫秒
            test.Name = "Two thread output";
            Console.WriteLine(test.Name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            Thread one = new Thread(new ThreadStart(a.OneMethod));
            Thread two = new Thread(new ThreadStart(a.TwoMethod));
            one.Start();
            two.Start();
            Console.ReadKey();
        }
    }

其輸出結果為：

one thread come in,sleep for 10 seconds

Empty

two thread come in//在第一個線程之間操作

Two thread output//在第一個線程鎖住test對象之中，改變的test。Name屬性值，說明鎖中test時將可以對test進行操作

One thread output

 

答案是：test對象在別的函數中被鎖中時，別的線程在被鎖塊外是可以對test進行操作的

假如我把第二個方法代碼做如下修改：

public void TwoMethod()
        {
            Thread.Sleep(100);//為了確保第一個線程先鎖住后在操作test對象
            Console.WriteLine("two thread come in");//假如由於線程一鎖住test對象而不能對test操作的話，那么要等待10000毫秒
            lock (this.test)
            {
                test.Name = "Two thread output";
                Console.WriteLine(test.Name);
            }            
        }

這時的結果是：

one thread come in,sleep for 10 seconds

Empty

two thread come in//在第一個線程獲得鎖之間線程二進入了第二方法中的鎖之前操作

One thread output//

Twothread output//說明鎖test被解鎖以后才執行

答案是：一個類中幾個方法鎖住了同一個對象（該對象必須是引用類型）時，那么第一個獲得鎖的線程操作，其他線程走到鎖對象（哪怕所對象不是在同一個函數中）之前將等待對象被解鎖，解鎖后才可以進入。打個比喻：test對象相當於一個響應器，lock（）鎖相當於一個鎖，操作系統相當於一個監控器，而一個或多個函數中的鎖塊相當於一個或多大門，多個線程相當於等在一個或多個大門前的人。假如有任一一個大門被一個人闖進時，那么監控器立即給所有鎖上鎖lock，鎖定所有大門，不准任何人進，直到該人出來，監控器自動打開所有鎖，所有大門打開，重復執行第一步，監控器保證只有一個人進入某一個大門。當然如果某一個響應器沒有lock，就相當於大門沒有鎖，就可以對test操作，這種情況就是上一種現象。

 

二、一道面試題（目前我也不太明白）

轉自 https://www.cnblogs.com/myshell/archive/2010/07/18/1780386.html

和https://q.cnblogs.com/q/47290/

public void test(int i) 
 { 
    lock(this) 
   { 
      if (i > 10) 
     { 
          i--; 
          test(i); 
      } 
    } 
 }

分析一下代碼，當調用test方法時i>10時是否會引起死鎖

不會。終於在《CLR via C#》第二版（中文版，清華大學出版社出版）的第530頁中第7行找到了這樣的描述：“同樣需要引起注意的是線程可以遞歸擁有同步塊”。即同一線程可以遞歸調用lock語句，這是單線程操作，該線程本身就是鎖的擁有者，當再次進入時，自然能獲取到進入該鎖塊的權利。

線程重入問題，lock會與線程關聯，如關聯上A1線程，那么A1線程重復進入多次也是OK的。但是lock又是獨占鎖，所以一旦關聯上線程，別的線程就無法進入lock代碼塊。

多線程操作時，會阻塞等待。