多线程数据同步、通信、死锁

　　故事发生在前几天，我被对象拖着去看房，对于我这种陈年老宅来说，那就是噩梦啊，虽然有诸多不满，但还是去了。出没于各大新旧楼宇之间，看了一天，要到下午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#的了解有所帮助