/* 基元线程同步构造

 用户模式构造：

     易变构造（Volatile Construct）

     互锁构造（Interlocked Construct）:自旋锁（Spinlock) 乐观锁（Optimistic Concurrency Control,乐观并发控制）

 内核模式构造：

     事件构造（Event)

     信号量构造（Semaphore)

     互斥体构造（Mutex)

 */

 //易变构造,Volatile.Write()之前的所有字段写入操作，必须再该方法调用之前完成，Volatile.Read()之前的所有字段读取操作，必须再该方法之前完成，保证该方法作用的字段

 //的赋值或读取顺序不被编译器优化，C#关键字volatile在语言层面提供了对易变构造的支持，标记为volatile的字段在按引用传递时无效。

 public static class Volatile

 {

     public static void Write(ref Int32 location,Int32 value);

     public static Int32 Read(ref Int32 location);

 }

 //互锁构造

 public static class Interlocked

 {

     public static Int32 Exchange(ref Int32 location,Int32 value);

     //Int32 old=location; if(location==comparand){ location=comparand;} return old;

     public static Int32 CompareExchange(ref Int32 location,Int32 value,Int32 comparand);

 }

 //简单自旋锁:自旋会浪费CPU时间，因此自旋锁只适用于执行的非常快的代码区域。在单CPU计算机上，希望获得锁的线程会不断的自旋，如果获得锁的线程优先级比较低的话，

 //会导致自旋的线程抢占CPU时间，从而影响拥有锁的线程释放锁，比较容易形成“活锁”。

 public struct SimpleSpinlock

 {

     private Int32 _inUse;//0：false,1:true，Interlocked不支持Boolean

     public void Enter()

     {

         while (true)

         {

             if(Interlocked.Exchange(ref _inUse,)==)

                 return;

             //一些其他代码

         }

     }

     public void Leave()

     {

         Volatile.Write(ref _inUse,);

     }

 }

 public class Demo

 {

     private SimpleSpinlock _spinLock;

     public void Access()

     {

         _spinLock.Enter();

         //取得锁，访问资源

         _spinLock.Leave();

     }

 }

 //欢乐锁：用于完成一次原子性的操作，如果在执行过程中，数据被外部修改，那么当前执行的过程就无效，然后用修改后的值重新进行这次原子性的操作。

 //说直白点就是乐观，与世无争。

 public class OptimisticLoack

 {

     public delegate T Morpher<T, TArgument>(T startValue, TArgument argument);

     public static T Morph<T, TArgument>(ref T target, TArgument value, Morpher<T,TArgument> morpher)where T:class

     {

         T currentValue = target, startValue, desiredValue;

         do

         {

             startValue = currentValue;

             desiredValue = morpher(startValue, value);

             currentValue = Interlocked.CompareExchange(ref target, desiredValue, startValue);

         } while (currentValue != startValue);

         return desiredValue;

     }

 }

 //事件构造：自动重置事件 手动重置事件

 public class EventWaitHandle:WaitHandle

 {

     public Boolean Set();

     public Boolean Reset();

 }

 public class AutoResetEvent():EventWaitHandle

 {

     public AutoResetEvent(Boolean initialState);

 }

 public class ManualResetEvent():EventWaitHandle

 {

     public ManualResetEvent(Boolean initialState);

 }

 //信号量构造

 public class Semaphore:WaitHandle

 {

     public Semaphore(Int32 initialCount,Int32 maxinumCount);

     public Int32 Release();

     public Int32 Release(Int32 releaseCount);

 }

 //互斥体构造,内部维护一个递归计数，可以实现递归锁

 public sealed class Mutex:WaitHandle

 {

     public Mutex ();

     public void ReleaseMutex();

 }

 //事件构造，信号量构造，互斥体构造均可以简单的实现自旋锁

 public class SimpleSpinlock

 {

     private readonly Mutex m_lock=new Mutex();//针对互斥体构造

     //private readonly Semaphore m_lock=new Semaphore();//针对信号量构造

     //private readonly AutoResetEvent m_lock=new AutoResetEvent(true);//针对事件构造

     public void Enter()

     {

         m_lock.WaitOne();

     }

     public void Leave()

     {

         m_lock.ReleaseMutex();//针对互斥体构造

         //m_lock.Release(1);//针对信号量构造

         //m_lock.Set();//针对事件构造

     }

 }