C# 温故而知新： 线程篇（三）上

/// <summary>
    /// 本例利用VolatileWrite和VolatileRead来实现同步，来实现一个计算
    /// 的例子，每个线程负责运算1000万个数据，共开启10个线程计算至1亿，
    /// 而且每个线程都无法干扰其他线程工作
    /// </summary>
    class Program
    {
        static Int32 count;//计数值，用于线程同步 （注意原子性，所以本例中使用int32）
        static Int32 value;//实际运算值，用于显示计算结果
        static void Main(string[] args)
        {
            //开辟一个线程专门负责读value的值，这样就能看见一个计算的过程
            Thread thread2 = new Thread(new ThreadStart(Read));
            thread2.Start();
            //开辟10个线程来负责计算，每个线程负责1000万条数据
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(20);
                Thread thread = new Thread(new ThreadStart(Write));
                thread.Start();
            }
            Console.ReadKey();
        }


        /// <summary>
        /// 实际运算写操作
        /// </summary>
        private static void Write()
        {
            Int32 temp = 0;
            for (int i = 0; i < 10000000; i++)
            {
                temp += 1;
            }
            value += temp;
            //注意VolatileWrite 在每个线程计算完毕时会写入同步计数值为1，告诉程序该线程已经执行完毕
            //所以VolatileWrite方法类似与一个按铃，往往在原子性的最后写入告诉程序我完成了
            Thread.VolatileWrite(ref count, 1);
        }


        /// <summary>
        ///  显示计算后的数据，使用该方法的线程会死循环等待写
        ///  操作的线程发出完毕信号后显示当前计算结果
        /// </summary>
        private static void Read()
        {
            while (true)
            {
                //一旦监听到一个写操作线执行完毕后立刻显示操作结果
                //和VolatileWrite相反，VolatileRead类似一个门禁，只有原子性的最先读取他，才能达到同步效果
                //同时count值保持最新
                if (Thread.VolatileRead(ref count) > 0)
                {
                    Console.WriteLine("累计计数:{1}", Thread.CurrentThread.ManagedThreadId, value);
                    //将count设置成0，等待另一个线程执行完毕
                    count = 0;
                }
            }
        }
    }

/// <summary>
    /// 本例利用volatile关键字来实现同步，来实现一个计算
    /// 的例子，每个线程负责运算1000万个数据，共开启10个线程计算至1亿，
    /// 而且每个线程都无法干扰其他线程工作
    /// </summary>
    class Program
    {
        static volatile Int32 count;//计数值，用于线程同步 （注意原子性，所以本例中使用int32）
        static Int32 value;//实际运算值，用于显示计算结果
        static void Main(string[] args)
        {
            //开辟一个线程专门负责读value的值，这样就能看见一个计算的过程
            Thread thread2 = new Thread(new ThreadStart(Read));
            thread2.Start();
            //开辟10个线程来负责计算，每个线程负责1000万条数据
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(20);
                Thread thread = new Thread(new ThreadStart(Write));
                thread.Start();
            }
            Console.ReadKey();
        }


        /// <summary>
        /// 实际运算写操作
        /// </summary>
        private static void Write()
        {
            Int32 temp = 0;
            for (int i = 0; i < 10000000; i++)
            {
                temp += 1;
            }
            value += temp;
            //注意VolatileWrite 在每个线程计算完毕时会写入同步计数值为1，告诉程序该线程已经执行完毕
            //将count值设置成1，效果等同于Thread.VolatileWrite
            count = 1;
        }


        /// <summary>
        ///  显示计算后的数据，使用该方法的线程会死循环等待写
        ///  操作的线程发出完毕信号后显示当前计算结果
        /// </summary>
        private static void Read()
        {
            while (true)
            {
                //一旦监听到一个写操作线执行完毕后立刻显示操作结果,效果等同于Thread.VolatileRead
                if (count==1)
                {
                    Console.WriteLine("累计计数:{1}", Thread.CurrentThread.ManagedThreadId, value);
                    //将count设置成0，等待另一个线程执行完毕
                    count = 0;
                }
            }
        }
    }

/// <summary>
    /// 本示例通过Interlocked实现同步示例，通过Interlocked.Increment和
    /// Interlocked.Decrement来实现同步，此例有2个共享区，一个必须满足计数值为0，另
    /// 一个满足计数值为1时才能进入
    /// </summary>
    class Program
    {
        //声明计数变量
        //（注意这里用的是long是64位的，所以在32位机子上一定要通过Interlocked来实现原子操作）
        static long _count = 0;


        static void Main(string[] args)
        {
            //开启6个线程，3个执行Excution1，三个执行Excution2
            for (int i = 0; i < 3; i++)
            {
                Thread thread = new Thread(new ThreadStart(Excution1));
                Thread thread2 = new Thread(new ThreadStart(Excution2));
                thread.Start();
                Thread.Sleep(10);
                thread2.Start();
                Thread.Sleep(10);
            }
            //这里和同步无关，只是简单的对Interlocked方法进行示例
            Interlocked.Add(ref _count, 2);
            Console.WriteLine("为当前计数值加上一个数量级:{0}后，当前计数值为:{1}", 2, _count);
            Interlocked.Exchange(ref _count, 1);
            Console.WriteLine("将当前计数值改变后，当前计数值为:{0}", _count);
            Console.Read();
        }


        static void Excution1()
        {
            //进入共享区1的条件
            if (Interlocked.Read(ref _count) == 0)
            {
                Console.WriteLine("Thread ID:{0} 进入了共享区1", Thread.CurrentThread.ManagedThreadId);
                //原子性增加计数值，让其他线程进入共享区2
                Interlocked.Increment(ref _count);
                Console.WriteLine("此时计数值Count为:{0}", Interlocked.Read(ref _count));
            }
        }


        static void Excution2()
        {
            //进入共享区2的条件
            if (Interlocked.Read(ref _count) == 1)
            {
                Console.WriteLine("Thread ID:{0} 进入了共享区2", Thread.CurrentThread.ManagedThreadId);
                //原子性减少计数值，让其他线程进入共享区1
                Interlocked.Decrement(ref _count);
                Console.WriteLine("此时计数值Count为:{0}", Interlocked.Read(ref _count));
            }
        }
    }

/// <summary>
    /// 本例展示下如何使用lock关键字和lock(this)时产生死锁的情况
    /// </summary>
    class Program
    {


        static void Main(string[] args)
        {
            //创建b对象，演示lock
            B b = new B();
            Console.ReadKey();
        }
    }


    /// <summary>
    /// A类构造中初始化一个线程并且启动，
    /// 线程调用的方法内放入死循环，并且在死循环中放入lock(this)，
    /// </summary>
    public class A
    {
        public A()
        {
            Thread th = new Thread(new ThreadStart
                (
                   () =>
                   {
                       while (true)
                       {
                           lock (this)
                           {
                               Console.WriteLine("进入a类共享区");
                               Thread.Sleep(3000);
                           }
                       }
                   }
                ));
            th.Start();
        }
    }


    /// <summary>
    ///  B类在构造中创建A的对象，并且还是锁住a对象，这样就创建的死锁的条件
    ///  因为初始化A类对象时，A类的构造函数会锁住自身对象，这样在A类死循环间隔期，一旦出了 A类中的锁时
    ///  进入B的锁住的区域内，A 对象永远无法进入a类共享区，从而产生了死锁
    /// </summary>
    public class B
    {
        public B()
        {
            A a = new A();
            lock (a)
            {
                Console.WriteLine(@"将a类对象锁住的话，a类中的lock将进入死锁，
                直到3秒后B类中的将a类对象释放锁,如果我不释放，那么 a类中将永远无法进入a类共享区");
                //计时器
                Timer timer = new Timer(new TimerCallback
                    (
                      (obj) => { Console.WriteLine(DateTime.Now); }
                    ), this, 0, 1000);
                //如果这里运行很长时间， a类中将永远无法进入a类共享区
                Thread.Sleep(3000000);
            }
        }
    }