C#线程学习笔记四：线程同步

    本笔记摘抄自：https://www.cnblogs.com/zhili/archive/2012/07/21/ThreadsSynchronous.html，记录一下学习过程以备后续查用。

    1、线程同步概述

    建立多线程来实现让咱们可以更好地响应应用程序，然而当咱们建立了多个线程时，就存在多个线程同时访问一个共享资源的状况。此时，咱们就须要用到线程同步。线程同

步能够防止数据（共享资源）的损坏。

    通常来讲，设计应用程序应尽可能避免使用线程同步， 由于线程同步会产生一些问题：

    1.一、它的使用比较繁琐。咱们须要用额外的代码，把多个线程同时访问的数据包围起来，并获取和释放一个线程同步锁。若是有一个代码块忘记获取锁，就有可能形成数据损坏。

    1.二、使用线程同步会影响性能。

        1.2.一、获取和释放一个锁是须要时间的，咱们在决定哪一个线程先获取锁的时候，CPU要进行协调，这些额外的工做就会对性能形成影响。

        1.2.二、线程同步一次只容许一个线程访问资源，这样就会阻塞线程，而阻塞线程会形成更多的线程被建立。这样CPU就有可能要调度更多的线程，从而对性能形成影响。 

    2、线程同步使用

    2.1 使用锁对性能的影响

    1.2.1描述过使用锁会对性能产生影响，下面经过比较使用锁和不使用锁消耗的时间来讲明这点：

    class Program
    {
        static void Main(string[] args)
        {
            #region 线程同步：使用与不使用锁的耗时对比
            int x = 0;
            //迭代500万次
            const int iterationNumber = 5000000;

            //不使用锁
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < iterationNumber; i++)
            {
                x++;
            }
            Console.WriteLine("Total time consuming is:{0}ms.", sw.ElapsedMilliseconds);

            sw.Restart();
            //使用锁
            for (int i = 0; i < iterationNumber; i++)
            {
                Interlocked.Increment(ref x);
            }

            Console.WriteLine("Total time consuming is:{0}ms.", sw.ElapsedMilliseconds);
            Console.Read();
            #endregion
        }
    }

    运行结果以下：

    2.2 Interlocked实现线程同步

    Interlocked为多个线程共享变量提供了原子操做，当咱们在多线程中对一个整数进行递增操做时，就须要实现线程同步。

    下面代码演示加锁与不加锁的区别：

    不加锁：

    class Program
    {
        //共享资源
        public static int number = 0;

        static void Main(string[] args)
        {
            #region 线程同步：使用Interlocked实现线程同步
            //不加锁
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(Add);
                thread.Start();
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// 递增不加锁
        /// </summary>
        public static void Add()
        {
            Thread.Sleep(1000);
            Console.WriteLine("The current value of number is:{0}", ++number);
        }
    }

    运行结果以下：

    结果与预期可能不太同样。为了解决这样的问题，咱们能够经过使用 Interlocked.Increment方法来实现自增操做。

    实现原理：相似银行叫号，当有空号且号码是本身的，才能去办理相关的业务，不然继续等待。

    加锁：

    class Program
    {
        //共享资源
        public static int number = 0;
        public static long signal = 0;

        static void Main(string[] args)
        {
            #region 线程同步：使用Interlocked实现线程同步
            //加锁
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ParameterizedThreadStart(AddWithInterlocked));
                thread.Start(i);
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// 递增长Interlocked锁
        /// </summary>
        public static void AddWithInterlocked(object parameter)
        {
            while (Interlocked.Read(ref signal) != 0 || (int)parameter != number)
            {
                Thread.Sleep(100);
            }

            Interlocked.Increment(ref signal);
            Console.WriteLine("The current value of number is:{0}", ++number);
            Interlocked.Decrement(ref signal);
        }
    }

    运行结果以下：

    2.3 Monitor实现线程同步

    对于上面那个状况，也能够经过Monitor.Enter和Monitor.Exit方法来实现线程同步。

    C#中经过lock关键字来提供简化的语法(lock能够理解为Monitor.Enter和Monitor.Exit方法的语法糖)。

    class Program
    {
        //共享资源
        public static int number = 0;
        private static readonly object addLock = new object();

        static void Main(string[] args)
        {
            #region 线程同步：使用Monitor实现线程同步
            //非语法糖
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(AddWithMonitor);
                thread.Start();
            }
            Console.Read();
            //语法糖
            //for (int i = 0; i < 10; i++)
            //{
            //    Thread thread = new Thread(AddWithLock);
            //    thread.Start();
            //}
            //Console.Read();
            #endregion
        }
        
        /// <summary>
        /// 递增长Monitor锁
        /// </summary>
        public static void AddWithMonitor()
        {
            Thread.Sleep(100);
            Monitor.Enter(addLock);
            Console.WriteLine("The current value of number is:{0}", ++number);
            Monitor.Exit(addLock);
        }

        /// <summary>
        /// 递增长Lock锁
        /// </summary>
        public static void AddWithLock()
        {
            Thread.Sleep(100);
            lock (addLock)
            {
                Console.WriteLine("The current value of number is:{0}", ++number);
            }
        }
    }

    运行结果以下：

    接上面的addLock锁(如下描述为obj锁)，顺便学习一下Monitor类的原理：

    Monitor在锁对象obj上会维持两个线程队列R和W以及一个引用T ：

    (1)T是对当前得到了obj锁的线程的引用。

    (2) R为就绪队列。

　R队列上的线程，是已经准备好了去竞争获取obj锁的线程。    

    线程可经过调用Monitor.Enter(obj)或Monitor.TryEnter(obj)而直接进入R队列，可经过调用Monitor.Exit(obj)或Monitor.Wait(obj)释放其所得到的obj锁。

    当obj锁被某个线程释放后，这个队列上的线程就会去竞争obj锁，而得到obj锁的线程将被T引用。

    (3) W为等待队列。

    W队列上的线程，是不会被OS直接调度执行的线程。也就是说，等待队列上的线程不能去得到obj锁。

    线程可经过调用Monitor.Wait(obj)而直接进入W队列，可经过调用Monitor.Pulse(obj)或Monitor.PulseAll(obj)将W队列中的第一个等待线程或全部等待线程移至R队列，

这时被移至R队列的这些线程就有机会被OS直接调度执行，也就是能够去竞争obj锁。

    (4)Monitor的成员方法。

    Monitor.Enter(obj)/Monitor.TryEnter(obj) ：线程会进入R队列以等待获取obj锁

    Monitor.Exit(obj) ：线程释放obj锁（只有获取了obj锁的线程才能执行Monitor.Exit(obj)）

    Monitor.Wait(obj)： 线程释放当前得到的obj锁，而后进入W队列并阻塞。

    Monitor.Pulse(obj) ：将W队列中的第一个等待线程移至R队列中以使第一个线程有机会获取obj锁。

    Monitor.PulseAll(obj)：将W队列中的全部等待线程移至R队列以使得这些线程有机会得到obj锁。

    下面代码演示Monitor.Wait及Monitor.Pulse的使用：

    class Program
    {
        //共享资源
        private static readonly object addLock = new object();

        static void Main(string[] args)
        {
            #region 线程同步：Monitor.Wait与Monitor.Pulse的使用
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(MonitorWaitAndPulse);
                thread.Start();
            }
            Console.Read();
            #endregion
        }

        /// <summary>
        /// Monitor中的Wait与Pulse方法
        /// </summary>
        public static void MonitorWaitAndPulse()
        {
            //进入就绪队列等待获取锁资源
            Monitor.Enter(addLock);
            //进来打声招呼
            Console.WriteLine("{0}：我来了，临时要出去办一下事。", Thread.CurrentThread.ManagedThreadId);
            //唤醒等待队列中的第一个线程进入就绪队列
            Monitor.Pulse(addLock);
            //暂时释放锁资源进入等待队列
            Monitor.Wait(addLock);
            //出去办事
            Thread.Sleep(1000);
            //回来打声招呼
            Console.WriteLine("{0}：我回来了。", Thread.CurrentThread.ManagedThreadId);
            //释放锁资源
            Monitor.Exit(addLock);
        }
    }

    运行结果以下：

    2.4 ReaderWriterLock实现线程同步

    若是咱们须要对一个共享资源执行屡次读取时，用前面所讲的类实现的同步锁都仅容许一个线程进行访问，而其它线程将被阻塞。因为只是进行读取操做，实际上是没有必要

堵塞其余的线程， 应该让它们并发的执行。

    此时，可经过ReaderWriterLock类来实现并行读取。

    class Program
    {
        //建立对象
        public static List<int> lists = new List<int>();
        public static ReaderWriterLock readerWriteLock = new ReaderWriterLock();

        static void Main(string[] args)
        {
            #region 线程同步：使用ReaderWriterLock实现线程同步
            //建立一个线程读取数据
            Thread threadWrite = new Thread(Write);
            threadWrite.Start();
            //建立10个线程读取数据
            for (int i = 0; i < 10; i++)
            {
                Thread threadRead = new Thread(Read);
                threadRead.Start();
            }

            Console.Read();
            #endregion
        }

        /// <summary>
        /// 写入方法
        /// </summary>
        public static void Write()
        {
            //获取写入锁，以10毫秒为超时。
            readerWriteLock.AcquireWriterLock(10);
            Random ran = new Random();
            int count = ran.Next(1, 10);
            lists.Add(count);
            Console.WriteLine("Write the data is:" + count);
            //释放写入锁
            readerWriteLock.ReleaseWriterLock();
        }

        /// <summary>
        /// 读取方法
        /// </summary>
        public static void Read()
        {
            Thread.Sleep(100);
            //获取读取锁
            readerWriteLock.AcquireReaderLock(10);

            foreach (int list in lists)
            {
                //输出读取的数据
                Console.WriteLine(list);
            }

            // 释放读取锁
            readerWriteLock.ReleaseReaderLock();
        }
    }

    运行结果以下：