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>
    /// 本示例通過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);
            }
        }
    }

    /// <summary>
    /// 該示例通過ReaderWriterLock同步來實現Student集合多線程下
    /// 的寫操作和讀操作
    /// </summary>
    class Program
    {
        static ReaderWriterLock _readAndWriteLock = new ReaderWriterLock();
        static List<Student> demoList = new List<Student>();

        static void Main(string[] args)
        {
            InitialStudentList();
            Thread thread=null;
            for (int i = 0; i <5; i++)
            {
              
                //讓第前2個個線程試圖掌控寫鎖,
                if (i < 2)
                {
                    thread = new Thread(new ParameterizedThreadStart(AddStudent));
                    Console.WriteLine("線程ID:{0}, 嘗試獲取寫鎖        ", thread.ManagedThreadId);
                    thread.Start(new Student { Name = "Zhang" + i });
                }
                else 
                {
                    //讓每個線程都能訪問DisplayStudent 方法去獲取讀鎖
                    thread = new Thread(new ThreadStart(DisplayStudent));
                    thread.Start();
                }
                Thread.Sleep(20);
            }
            Console.ReadKey();
        }

        static void InitialStudentList() 
        {
            demoList = new List<Student> { new Student{ Name="Sun"}, new Student{Name="Zheng"} };
        }

        /// <summary>
        /// 當多個線程試圖使用該方法時，只有一個線程能夠透過AcquireSWriterLock
        /// 獲取寫鎖，同時其他線程進入隊列中等待，直到該線程使用ReleaseWriterLock后
        /// 下個線程才能進入擁有寫鎖
        /// </summary>
        /// <param name="student"></param>
        static void AddStudent(object student)
        {
            if (student == null|| !(student is Student)) return;
            if (demoList.Contains(student)) return;
            try
            {
                //獲取寫鎖
                _readAndWriteLock.AcquireWriterLock(Timeout.Infinite);
                demoList.Add(student as Student);
                Console.WriteLine("當前寫操作線程為{0},            寫入的學生是：{1}", Thread.CurrentThread.ManagedThreadId,(student as Student).Name);
            }
            catch (Exception)
            {

            }
            finally
            {
                _readAndWriteLock.ReleaseWriterLock();
            }

        }

        /// <summary>
        /// 對于讀鎖來所，允許多個線程共同擁有，所以這里同時
        /// 可能會有多個線程訪問Student集合，使用try catch是為了
        /// 一定要讓程序執行finally語句塊中的releaseXXX方法，從而保證
        /// 能夠釋放鎖
        /// </summary>
        static void DisplayStudent()
        {
            try
            {
                _readAndWriteLock.AcquireReaderLock(Timeout.Infinite);
                demoList.ForEach(student
                  =>
                {
                    Console.WriteLine("當前集合中學生為:{0},當前讀操作線程為{1}", student.Name, Thread.CurrentThread.ManagedThreadId);
                });
            }
            catch (Exception)
            {
              
            }
            finally
            {
                _readAndWriteLock.ReleaseReaderLock();
            }
        }

    }

    internal class Student
    {
        public string Name { get; set; }
    }