/// 线程的资源访问冲突：多个线程同时申请一个资源，造成读写错乱。
    /// 解决方案：上锁，lock{执行的程序段}:同一时刻，只允许一个线程访问该程序段。
    /// 死锁问题：
    /// 程序中的锁过多，某一线程需要多个锁资源，而某个资源被另一线程占用，另一个线程同样如此，（谁也不愿先释放资源）形成闭环，线程无法继续进行。
    /// 解决方案：使用调度算法，让某一个被占用的资源被线程释放或关闭某个线程。 

// 资源访问冲突

    class State
    {
        private Object _lock = new Object();
        private int state = 100;
        private void test()
        {
            if(100 == state)
            {
                Console.Write("state=" + state);
            }
            state++;
        }
        private void test2()
        {
            if (101 == state)
            {
                Console.Write("state=" + state);
            }
            state++;
        }

        public void ChangeState()
        {
            Thread h = new Thread(test);
            Thread v = new Thread(test2);

            // h.Start();
            // v.Start();
            // state=100state=100state=101state=100请按任意键继续. . .

            lock (_lock)
            {
                h.Start();
                v.Start();
                // state=100请按任意键继续. . .
                // state=100state=101请按任意键继续. . .
            }
        }
    }

// 主程序

    class StateProgram
    {
        static void Main(string[] args)
        {
            State state = new State();

            for (int i = 0; i < 10; i++)
            {
                Thread t = new Thread(state.ChangeState);
                t.Start();
            }
            Thread.Sleep(1000);
        }
    }

// 死锁

    class Deadlock
    {
        Object _lock = new Object();
        Object _lock2 = new Object();

        private int flag = 0;

        public void test()
        {
            lock (_lock)
            {
                Console.WriteLine("我拿到了锁1");
                lock (_lock2)
                {
                    Console.WriteLine("我拿到了锁2");
                    if(0 == flag)
                    {
                        Console.WriteLine("我是第一名");
                        flag = 1;
                    }
                    else
                    {
                        Console.WriteLine("我是第二名");
                    }
                }
            }
        }

        public void test2()
        {
            lock (_lock2)
            {
                Console.WriteLine("他拿到了锁2");
                lock (_lock)
                {
                    Console.WriteLine("他拿到了锁1");
                    if (0 == flag)
                    {
                        Console.WriteLine("他是第一名");
                        flag = 1;
                    }
                    else
                    {
                        Console.WriteLine("他是第二名");
                    }
                }
            }
        }
    }

// 主程序

            Deadlock star = new Deadlock();

            Thread t1 = new Thread(star.test);
            Thread t2 = new Thread(star.test2);

            t1.Start();
            t2.Start();
            //我拿到了锁1
            //他拿到了锁2

// 解决方案1:锁同步

    class Deadlock
    {
        Object _lock = new Object();
        Object _lock2 = new Object();

        private int flag = 0;

        public void test()
        {
            lock (_lock)
            {
                Console.WriteLine("我拿到了锁1");
                lock (_lock2)
                {
                    Console.WriteLine("我拿到了锁2");
                    if(0 == flag)
                    {
                        Console.WriteLine("我是第一名");
                        flag = 1;
                    }
                    else
                    {
                        Console.WriteLine("我是第二名");
                    }
                }
            }
        }

        public void test2()
        {
            lock (_lock)
            {
                Console.WriteLine("他拿到了锁2");
                lock (_lock2)
                {
                    Console.WriteLine("他拿到了锁1");
                    if (0 == flag)
                    {
                        Console.WriteLine("他是第一名");
                        flag = 1;
                    }
                    else
                    {
                        Console.WriteLine("他是第二名");
                    }
                }
            }
        }
    }

我拿到了锁1
我拿到了锁2
我是第一名
他拿到了锁2
他拿到了锁1
他是第二名
请按任意键继续. . . 

// 解决方案2:做标签

    class Deadlock
    {
        Object _lock = new Object();
        Object _lock2 = new Object();

        private int flag = 0;
        private int _flag = 0;

        public void test()
        {
            if (0 == _flag)
            {
                lock (_lock)
                {
                    Console.WriteLine("我拿到了锁1");
                    lock (_lock2)
                    {
                        Console.WriteLine("我拿到了锁2");
                        if (0 == flag)
                        {
                            Console.WriteLine("我是第一名");
                            flag = 1;
                        }
                        else
                        {
                            Console.WriteLine("我是第二名");
                        }
                    }
                }
            }
            _flag = 1;
        }

        public void test2()
        {
            if(1 == _flag)
            {
                lock (_lock2)
                {
                    Console.WriteLine("他拿到了锁2");
                    lock (_lock)
                    {
                        Console.WriteLine("他拿到了锁1");
                        if (0 == flag)
                        {
                            Console.WriteLine("他是第一名");
                            flag = 1;
                        }
                        else
                        {
                            Console.WriteLine("他是第二名");
                        }
                    }
                }
            }

        }
    }

            Deadlock star = new Deadlock();
            Thread t1 = new Thread(star.test);
            Thread t2 = new Thread(star.test2);

            t1.Start();
            Thread.Sleep(1000);
            t2.Start();

我拿到了锁1
我拿到了锁2
我是第一名
他拿到了锁2
他拿到了锁1
他是第二名
请按任意键继续. . .