多線程數據同步、通信、死鎖

　　故事發生在前幾天，我被對象拖着去看房，對於我這種陳年老宅來說，那就是噩夢啊，雖然有諸多不滿，但還是去了。出沒於各大新舊樓宇之間，看了一天，要到下午5點左右，終於看好了一個新樓盤，然后看看戶型，問問朝向等。都覺得還不錯，就准備入手，然后自己還各種科普買房知識，以為准備已充分，合同簽了，交了錢，就完事，高高興興地就回家了。

　　第二天，我對象拿出合同准備再仔細看了看合同內容，然后猛地才發現，合同居然沒蓋章，這下可把我急着了，這豈不是可以一房多賣，合同都不跟我們蓋章，那豈不是合同未生效啊，太氣人了，於是趕緊找他們理論，吵吵半天之后蓋了章。

　　於是乎，我想到了兩個問題

　　銷售員未和我們協商到最后一刻，然后由另一個銷售接手（多個線程同時操作同一個數據源）

　　合同未完成，就給我們（多線程數據的一致性，lock）

　　在多任務系統中，每個獨立執行的程序稱為進程，也就是正在進行的程序，現在使用的操作系統一般都是多任務的，即能夠同時執行多個應用程序，實際情況是，操作系統負責對CPU等設備的資源進行分配和管理，雖然這些設備某一時刻只能做一件事，但以非常小的時間間隔交替執行多個程序，就可以給人以同時執行多個程序的感覺，怎么證明這一點呢？

class TestThread
{
    public static void Main(string[] args)
    {
        Thread t = new Thread(new ThreadStart(new Thread1().Run));
        try
        {
            t.Start();
        }
        catch (Exception ex)
        {
            throw ex;
        }

        while (true)
        {
            Console.WriteLine("主線程正在執行...");
        }
    }
}

class Thread1
{
    public void Run()
    {
        while (true)
        {
            Console.WriteLine("子線程正在執行...");
        }
    }
}

執行結果：可以看到操作系統是輪流分配CPU執行主線程和子線程的

 

讓一個線程中在執行到lock的代碼塊時不會切換CPU，而是執行完之后才允許切換CPU到另一個線程，保證數據的完整性

什么情況下會讓一房多賣呢，現在我們就用多線程模擬下一房多賣的場景

假設，有100套房子要賣，同時有四個銷售員在賣，此時的代碼如下：

class TestThread
{
    public static void Main(string[] args)
    {
        // 一房多賣  
        Thread t1 = new Thread(new ThreadStart(new Thread2().Run));
        t1.Name = "銷售員A";
        t1.Start();
        Thread t2 = new Thread(new ThreadStart(new Thread2().Run));
        t2.Name = "銷售員B";
        t2.Start();
        Thread t3 = new Thread(new ThreadStart(new Thread2().Run));
        t3.Name = "銷售員C";
        t3.Start();
        Thread t4 = new Thread(new ThreadStart(new Thread2().Run));
        t4.Name = "銷售員D";
        t4.Start();
    }
}

class Thread2
{
    public int house = 100;

    // 重點！！！
    // string是引用類型，可以當作lock鎖定對象,其他值類型是不能用來lock的
    public string lockObj = string.Empty;

    // 會拋出異常 error CS0185: “int”不是 lock 語句要求的引用類型
    // public int lockInt = 0;

    public void Run()
    {
        while (true)
        {
            lock (lockObj)
            {
                if (house > 0)
                {
                    // 重現存在線程不同步，導致的線程安全問題
                    // 解決辦法，加入線程同步鎖
                    Thread.Sleep(10);
                    Console.WriteLine(Thread.CurrentThread.Name + " 正在賣 " + house + "號房");
                    house--;
                }
            }
        }
    }
}

執行結果：同一個房子被賣了三次，原因就在於三個銷售員，沒有用同一個房源，而且互相之間也沒有通信，不知道對方賣了那個房子

 接下來我們就要讓四個銷售員都賣同一個房源，並且要在銷售之前加上鎖，防止別人和自己同時在賣一套房子

class TestThread
{
    public static void Main(string[] args)
    {
        // 一房一賣
        ThreadStart method = new ThreadStart(new Thread2().Run);
        Thread t1 = new Thread(method);
        t1.Name = "銷售員A";
        t1.Start();
        Thread t2 = new Thread(method);
        t2.Name = "銷售員B";
        t2.Start();
        Thread t3 = new Thread(method);
        t3.Name = "銷售員C";
        t3.Start();
        Thread t4 = new Thread(method);
        t4.Name = "銷售員D";
        t4.Start();
    }
}

class Thread2
{
    public int house = 100;

    // 重點！！！
    // string是引用類型，可以當作lock鎖定對象,其他值類型是不能用來lock的
    public string lockObj = string.Empty;

    // 會拋出異常 error CS0185: “int”不是 lock 語句要求的引用類型
    // public int lockInt = 0;

    public void Run()
    {
        while (true)
        {
            lock (lockObj)
            {
                if (house > 0)
                {
                    // 重現存在線程不同步，導致的線程安全問題
                    // 解決辦法，加入線程同步鎖
                    Thread.Sleep(10);
                    Console.WriteLine(Thread.CurrentThread.Name + " 正在賣 " + house + "號房");
                    house--;
                }
            }
        }
    }
}

執行結果：房子一房多賣的情況已被解決

 多個線程互相等待對方的鎖定標識未被釋放，就會產生死鎖

class TestThread
{
    public static void Main(string[] args)
    {
        // 重現死鎖問題
        Thread3 thread3 = new Thread3();
        Thread t1 = new Thread(new ThreadStart(thread3.Run));
        t1.Name = "銷售員A";
        t1.Start();
        Thread.Sleep(1);
        thread3.lockObj = "中介";
        Thread t2 = new Thread(new ThreadStart(thread3.Run));
        t2.Name = "銷售員B";
        t2.Start();
    }
}

class Thread3
{
    public string lockObj = string.Empty;
    public int house = 100;

    public void Run()
    {
        if (lockObj == "中介")
        {
            while (true)
            {
                lock (this)
                {
                    if (house > 0)
                    {
                        // 重現存在線程不同步，導致的線程安全問題
                        // 解決辦法，加入線程同步鎖
                        Thread.Sleep(10);
                        // 死鎖問題
                        lock (lockObj) { }
                        Console.WriteLine(lockObj + "的" + Thread.CurrentThread.Name + " 正在賣 " + (house--) + "號房");
                        ;
                    }
                }
            }
        }
        else
        {
            while (true)
            {
                lock (lockObj)
                {
                    if (house > 0)
                    {
                        // 重現存在線程不同步，導致的線程安全問題
                        // 解決辦法，加入線程同步鎖
                        Thread.Sleep(10);
                        // 死鎖問題
                        lock (this) { }
                        Console.WriteLine("內部的" + Thread.CurrentThread.Name + " 正在賣 " + (house--) + "號房");
                    }
                }
            }
        }
    }
}

執行結果：結果顯示，多線程已經卡住了，發生了死鎖的情況，原因就是雙方都等着對方先出售，自己再賣

waitOne 告訴當前線程放棄CPU並進入睡眠狀態直到其他線程進入同一個監視器並調用Set為止

多線程之間難免會遇到需要相互打交道的時候，舉個例子，開發商為了防止銷售員偷懶，就交替為銷售員分配客戶，下面我們就用代碼去模擬下這個場景

class ThreadCommunation
{
    public static void Main(string[] args)
    {
        // 實現銷售員A和銷售員B交替分配客戶
        Q q = new Q();

        // 測試多線程之前的通信
        new Thread(new ThreadStart(new Producer(q).Run)).Start();
        new Thread(new ThreadStart(new Customer(q).Run)).Start();
    }
}

/// <summary>
/// DTO
/// </summary>
class Q
{
    private EventWaitHandle e = new AutoResetEvent(false);
    private readonly object lockA = new object();
    private readonly object lockB = new object();
    private string seller = "unknown";
    private string house = "unknown";
    private bool bFull = false;
    private bool isStop = false;

    public Q()
    {

    }

    public Q(string seller, string house)
    {
        this.seller = seller;
        this.house = house;
    }

    public void Stop()
    {
        this.isStop = true;
    }

    public void Put(string seller, string house)
    {
        // 重點！！！
        // 不能用同一個鎖定標識，會產生死鎖
        lock (lockA)
        {
            if (this.bFull)
            {
                // 等待被另一個線程清空后再插入數據
                e.WaitOne();
            }
            this.seller = seller;
            Thread.Sleep(1);
            this.house = house;
            this.bFull = true;

            // 通知等待的線程可以繼續執行
            e.Set();
        }
    }

    public void Get()
    {
        if (!this.isStop)
        {
            // 重點！！！
            // 不能用同一個鎖定標識，會產生死鎖
            lock (lockB)
            {
                if (!this.bFull)
                {
                    // 等待被另一個線程清空后再插入數據
                    e.WaitOne();
                }
                Console.WriteLine(this.ToString());
                this.bFull = false;

                // 通知等待的線程可以繼續執行
                e.Set();
            }
        }
    }

    public override string ToString()
    {
        return "銷售員：" + this.seller + "正在接待：" + this.house + "號客戶";
    }
}

/// <summary>
/// 生產者
/// </summary>
class Producer
{
    private Q q;

    public Producer(Q q)
    {
        this.q = q;
    }

    public void Run()
    {
        int i = 0;
        int house = 100;
        while (true)
        {
            if (house > 0)
            {
                if (i == 0)
                {
                    q.Put("銷售員A", (house--).ToString());
                }
                else
                {
                    q.Put("銷售員B", (house--).ToString());
                }

                i = (i + 1) % 2;
            }
            else
            {
                q.Stop();
            }
        }
    }
}

/// <summary>
/// 消費者
/// </summary>
class Customer
{
    private Q q;

    public Customer(Q q)
    {
        this.q = q;
    }

    public void Run()
    {
        while (true)
        {
            q.Get();
        }
    }
}

執行結果：可以看出銷售員A和銷售員B正在交替接待客戶

總結：理論不是太多，全是實踐而來的干貨，希望對大家對C#的了解有所幫助