C#之线程同步

参考：线程之线程同步

多个线程同时使用共享对象会造成很多问题，同步这些线程使得对共享对象的操作能够以正确的顺序执行是非常重要的。如果无需共享对象，就无需进行线程同步。大多数时候可以通过重新设计程序来移除共享状态，从而去掉复杂的同步构造。要尽可能避免在多个线程间使用单一对象。

 原子操作

所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切 [1]  换到另一个线程）。

using System;
using System.Threading;

namespace Chapter2.Recipe1
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("Incorrect counter");

            var c = new Counter();

            var t1 = new Thread(() => TestCounter(c));//3个线程共享同一对象c
            var t2 = new Thread(() => TestCounter(c));
            var t3 = new Thread(() => TestCounter(c));
            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();

            Console.WriteLine("Total count: {0}", c.Count); //计算结果是不确定的
            Console.WriteLine("--------------------------");

            Console.WriteLine("Correct counter");

            var c1 = new CounterNoLock();

            t1 = new Thread(() => TestCounter(c1));
            t2 = new Thread(() => TestCounter(c1));
            t3 = new Thread(() => TestCounter(c1));
            t1.Start();
            t2.Start();
            t3.Start();
            t1.Join();
            t2.Join();
            t3.Join();

            Console.WriteLine("Total count: {0}", c1.Count);
            Console.ReadKey();
        }

        static void TestCounter(CounterBase c)
        {
            for (int i = 0; i < 100000; i++)
            {
                c.Increment();
                c.Decrement();
            }
        }

        class Counter : CounterBase
        {
            private int _count;

            public int Count { get { return _count; } }

            public override void Increment()
            {
                _count++;
            }

            public override void Decrement()
            {
                _count--;
            }
        }

        class CounterNoLock : CounterBase
        {
            private int _count;

            public int Count { get { return _count; } }

            public override void Increment()
            {
                //Interlocked类提供了基本数学操作的原子方法
                Interlocked.Increment(ref _count);
            }

            public override void Decrement()
            {
                Interlocked.Decrement(ref _count);
            }
        }

        abstract class CounterBase
        {
            public abstract void Increment();

            public abstract void Decrement();
        }
    }
}

 使用Mutex类

参考msdn

using System;
using System.Threading;

namespace Chapter2.Recipe2
{
    class Example
    {
        // Create a new Mutex. The creating thread does not own the mutex.
        private static Mutex mut = new Mutex();
        private const int numIterations = 1;
        private const int numThreads = 3;

        static void Main()
        {
            // Create the threads that will use the protected resource.
            for (int i = 0; i < numThreads; i++)
            {
                Thread newThread = new Thread(new ThreadStart(ThreadProc));
                newThread.Name = String.Format("Thread{0}", i + 1);
                newThread.Start();
            }

            // The main thread exits, but the application continues to
            // run until all foreground threads have exited.
        }

        private static void ThreadProc()
        {
            for (int i = 0; i < numIterations; i++)
            {
                UseResource();
            }
        }

        // This method represents a resource that must be synchronized
        // so that only one thread at a time can enter.
        private static void UseResource()
        {
            // Wait until it is safe to enter.
            Console.WriteLine("{0} is requesting the mutex",
                              Thread.CurrentThread.Name);
            mut.WaitOne();

            Console.WriteLine("{0} has entered the protected area",
                              Thread.CurrentThread.Name);

            // Place code to access non-reentrant resources here.

            // Simulate some work.
            Thread.Sleep(500);

            Console.WriteLine("{0} is leaving the protected area",
                Thread.CurrentThread.Name);

            // Release the Mutex.
            mut.ReleaseMutex();
            Console.WriteLine("{0} has released the mutex",
                Thread.CurrentThread.Name);
        }
    }
}

using System;
using System.Threading;

namespace Chapter2.Recipe2
{
    class Example
    {
        // Create a new Mutex. The creating thread does not own the mutex.
        private static Mutex mut = new Mutex();
        private const int numIterations = 1;
        private const int numThreads = 3;

        static void Main()
        {
            Example ex = new Example();
            ex.StartThreads();
        }

        private void StartThreads()
        {
            // Create the threads that will use the protected resource.
            for (int i = 0; i < numThreads; i++)
            {
                Thread newThread = new Thread(new ThreadStart(ThreadProc));
                newThread.Name = String.Format("Thread{0}", i + 1);
                newThread.Start();
            }

            // The main thread returns to Main and exits, but the application continues to
            // run until all foreground threads have exited.
        }

        private static void ThreadProc()
        {
            for (int i = 0; i < numIterations; i++)
            {
                UseResource();
            }
        }

        // This method represents a resource that must be synchronized
        // so that only one thread at a time can enter.
        private static void UseResource()
        {
            // Wait until it is safe to enter, and do not enter if the request times out.
            Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
            //调用WaitOne()来获取互斥体，如果超时，WaitOne()返回false,线程没有获取到互斥体，没有访问资源的权限。
            if (mut.WaitOne(1000)) //设置超时时间1s
            {
                Console.WriteLine("{0} has entered the protected area",
                    Thread.CurrentThread.Name);

                // Place code to access non-reentrant resources here.

                // Simulate some work.
                Thread.Sleep(5000);

                Console.WriteLine("{0} is leaving the protected area",
                    Thread.CurrentThread.Name);

                // Release the Mutex.
                mut.ReleaseMutex();
                Console.WriteLine("{0} has released the mutex",
                                  Thread.CurrentThread.Name);
            }
            else
            {
                Console.WriteLine("{0} will not acquire the mutex",
                                  Thread.CurrentThread.Name);
            }
        }

        ~Example()
        {
            mut.Dispose();
        }
    }
}

 使用SemaphoreSlim类

SemaphoreSlim类是Semaphore类的轻量级版本，该类限制了同时访问同一个资源的线程数量。

using System;
using System.Threading;

namespace Chapter2.Recipe3
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 1; i <= 6; i++)
            {
                string threadName = "Thread " + i;
                int secondsToWait = 2 + 2 * i;
                var t = new Thread(() => AccessDatabase(threadName, secondsToWait));
                t.Start();
            }
        }
        //指定并发线程数量为4
        static SemaphoreSlim _semaphore = new SemaphoreSlim(4);

        static void AccessDatabase(string name, int seconds)
        {
            Console.WriteLine("{0} waits to access a database", name);
            _semaphore.Wait();
            Console.WriteLine("{0} was granted an access to a database", name);
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            Console.WriteLine("{0} is completed", name);
            _semaphore.Release();

        }
    }
}

 使用AutoResetEvent类

AutoResetEvent类可以通知等待的线程有某事件发生。此类不能被继承。

• 　AutoResetEvent(bool initialState)：构造函数，用一个指示是否将初始状态设置为终止的布尔值初始化该类的新实例。

    　　　　false：无信号，子线程的WaitOne方法不会被自动调用

  　　　　  true：有信号，子线程的WaitOne方法会被自动调用

• 　Reset ()：将事件状态设置为非终止状态，导致线程阻止；如果该操作成功，则返回true；否则，返回false。

• 　Set ()：将事件状态设置为有信号，从而允许一个或者多个等待线程继续执行；如果该操作成功，则返回true；否则，返回false。

• 　WaitOne()： 阻止当前线程，直到收到信号。如果收到信号，则返回true,如果当前实例永不发出信号，则WaitOne()永不返回。
•    WaitOne(Int32) ：阻止当前线程，直到收到信号，同时指定超时时间间隔。线程被阻止直到收到信号或者超时发生。如果收到信号则返回true,否则返回false。

• 　WaitOne(TimeSpan, Boolean) ：阻止当前线程，直到当前实例收到信号，使用 TimeSpan 度量时间间隔并指定是否在等待之前退出同步域。   

•   WaitAll()：等待全部信号。

AutoResetEvent.WaitOne()每次只允许一个线程进入，当某个线程得到信号后，AutoResetEvent会自动又将信号置为不发送状态，则其他调用WaitOne的线程只有继续等待，也就是说AutoResetEvent一次只唤醒一个线程；

using System;
using System.Threading;

namespace Chapter2.Recipe4
{
    class WaitOne
    {
        static AutoResetEvent autoEvent = new AutoResetEvent(false);

        static void Main()
        {
            Console.WriteLine("Main starting.");

            ThreadPool.QueueUserWorkItem(
                new WaitCallback(WorkMethod), autoEvent);

            // Wait for work method to signal.
            if (autoEvent.WaitOne(1000))
            {
                Console.WriteLine("Work method signaled.");
            }
            else
            {
                Console.WriteLine("Timed out waiting for work " +
                    "method to signal.");
            }
            Console.WriteLine("Main ending.");
        }

        static void WorkMethod(object stateInfo)
        {
            Console.WriteLine("Work starting.");

            // Simulate time spent working.
            Thread.Sleep(new Random().Next(100, 2000));

            // Signal that work is finished.
            Console.WriteLine("Work ending.");
            ((AutoResetEvent)stateInfo).Set();
        }
    }
}

 使用ManualResetEventSlim类

AutoResetEvent类似一个旋转门，一次只允许一人通过。而ManualResetEventSlim类似人群通过大门，会一直保持大门打开直到手动调用Reset方法。

除非手工调用了ManualResetEvent.Reset()方法，则ManualResetEvent将一直保持有信号状态，ManualResetEvent也就可以同时唤醒多个线程继续执行。

 使用CountDownEvent类

表示在计数变为零时处于有信号状态的同步基元。

using System;
using System.Threading;

namespace Chapter2.Recipe6
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Starting two operations");
            var t1 = new Thread(() => PerformOperation("Operation 1 is completed", 4));
            var t2 = new Thread(() => PerformOperation("Operation 2 is completed", 8));
            t1.Start();
            t2.Start();
            _countdown.Wait();
            Console.WriteLine("Both operations have been completed.");
            _countdown.Dispose();
        }

        static CountdownEvent _countdown = new CountdownEvent(2);

        static void PerformOperation(string message, int seconds)
        {
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            Console.WriteLine(message);
            //     向 System.Threading.CountdownEvent 注册信号，同时减小 System.Threading.CountdownEvent.CurrentCount
            //     的值。
            _countdown.Signal();
        }
    }
}

 使用Barrier类

参考文章

Barrier类用于组织多个线性及时在某一时刻碰面，其提供了一个回调函数，每次线程调用了SignalAndWait方法后，该回调函数会被执行。它像一个屏障，把所有任务的阶段隔离开来，当前阶段不完成，不会开始下一个阶段。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace Sample5_1_barrier
{
    class Program
    {
        private static void Phase0Doing(int TaskID)
        {
            Console.WriteLine("Task : #{0}   =====  Phase 0", TaskID);
        }

        private static void Phase1Doing(int TaskID)
        {
            Console.WriteLine("Task : #{0}   *****  Phase 1", TaskID);
        }

        private static void Phase2Doing(int TaskID)
        {
            Console.WriteLine("Task : #{0}   ^^^^^  Phase 2", TaskID);
        }

        private static void Phase3Doing(int TaskID)
        {
            Console.WriteLine("Task : #{0}   $$$$$  Phase 3", TaskID);
        }

        private static int _TaskNum = 4;
        private static Task[] _Tasks;
        private static Barrier _Barrier;


        static void Main(string[] args)
        {
            _Tasks = new Task[_TaskNum];
            _Barrier = new Barrier(_TaskNum, (barrier) =>
            {
                Console.WriteLine("-------------------------- Current Phase:{0} --------------------------",
                                  _Barrier.CurrentPhaseNumber);
            });

            for (int i = 0; i < _TaskNum; i++)
            {
                _Tasks[i] = Task.Factory.StartNew((num) =>
                {
                    var taskid = (int)num;

                    Phase0Doing(taskid);
                    _Barrier.SignalAndWait(); // 发出参与者已达到屏障并等待所有其他参与者也达到屏障

                    Phase1Doing(taskid);
                    _Barrier.SignalAndWait();

                    Phase2Doing(taskid);
                    _Barrier.SignalAndWait();

                    Phase3Doing(taskid);
                    _Barrier.SignalAndWait();

                }, i);
            }

            var finalTask = Task.Factory.ContinueWhenAll(_Tasks, (tasks) =>
            {
                Task.WaitAll(_Tasks);
                Console.WriteLine("========================================");
                Console.WriteLine("All Phase is completed");

                _Barrier.Dispose();
            });

            finalTask.Wait();

            Console.ReadLine();
        }
    }
}

 使用ReaderWriterLockSlim类

ReaderWriterLockSlim代表了一个管理资源访问的锁，允许多个线程同时读取，以及独占写。