1 /* 基元線程同步構造
  2 用戶模式構造：
  3     易變構造（Volatile Construct）
  4     互鎖構造（Interlocked Construct）:自旋鎖（Spinlock) 樂觀鎖（Optimistic Concurrency Control,樂觀并發控制）
  5 內核模式構造：
  6     事件構造（Event)
  7     信號量構造（Semaphore)
  8     互斥體構造（Mutex)
  9 */
 10 
 11 //易變構造,Volatile.Write()之前的所有字段寫入操作，必須再該方法調用之前完成，Volatile.Read()之前的所有字段讀取操作，必須再該方法之前完成，保證該方法作用的字段
 12 //的賦值或讀取順序不被編譯器優化，C#關鍵字volatile在語言層面提供了對易變構造的支持，標記為volatile的字段在按引用傳遞時無效。
 13 public static class Volatile
 14 {
 15     public static void Write(ref Int32 location,Int32 value);
 16     public static Int32 Read(ref Int32 location);
 17 }
 18 
 19 //互鎖構造
 20 public static class Interlocked
 21 {
 22     public static Int32 Exchange(ref Int32 location,Int32 value);
 23 
 24     //Int32 old=location; if(location==comparand){ location=comparand;} return old;
 25     public static Int32 CompareExchange(ref Int32 location,Int32 value,Int32 comparand);
 26 }
 27 
 28 //簡單自旋鎖:自旋會浪費CPU時間，因此自旋鎖只適用于執行的非常快的代碼區域。在單CPU計算機上，希望獲得鎖的線程會不斷的自旋，如果獲得鎖的線程優先級比較低的話，
 29 //會導致自旋的線程搶占CPU時間，從而影響擁有鎖的線程釋放鎖，比較容易形成“活鎖”。
 30 public struct SimpleSpinlock
 31 {
 32     private Int32 _inUse;//0：false,1:true，Interlocked不支持Boolean
 33     public void Enter()
 34     {
 35         while (true)
 36         {
 37             if(Interlocked.Exchange(ref _inUse,1)==0)
 38                 return;
 39             //一些其他代碼
 40         }
 41     }
 42     public void Leave()
 43     {
 44         Volatile.Write(ref _inUse,0);
 45     }
 46 }
 47 public class Demo
 48 {
 49     private SimpleSpinlock _spinLock;
 50     public void Access()
 51     {
 52         _spinLock.Enter();
 53         //取得鎖，訪問資源
 54         _spinLock.Leave();
 55     }
 56 }
 57 
 58 
 59 //歡樂鎖：用于完成一次原子性的操作，如果在執行過程中，數據被外部修改，那么當前執行的過程就無效，然后用修改后的值重新進行這次原子性的操作。
 60 //說直白點就是樂觀，與世無爭。
 61 public class OptimisticLoack
 62 {
 63     public delegate T Morpher<T, TArgument>(T startValue, TArgument argument);
 64     public static T Morph<T, TArgument>(ref T target, TArgument value, Morpher<T,TArgument> morpher)where T:class
 65     {
 66         T currentValue = target, startValue, desiredValue;
 67         do
 68         {
 69             startValue = currentValue;
 70             desiredValue = morpher(startValue, value);
 71             currentValue = Interlocked.CompareExchange(ref target, desiredValue, startValue);
 72         } while (currentValue != startValue);
 73         return desiredValue;
 74     }
 75 }
 76 
 77 //事件構造：自動重置事件 手動重置事件
 78 public class EventWaitHandle:WaitHandle
 79 {
 80     public Boolean Set();
 81     public Boolean Reset();
 82 }
 83 public class AutoResetEvent():EventWaitHandle
 84 {
 85     public AutoResetEvent(Boolean initialState);
 86 }
 87 public class ManualResetEvent():EventWaitHandle
 88 {
 89     public ManualResetEvent(Boolean initialState);
 90 }
 91 
 92 //信號量構造
 93 public class Semaphore:WaitHandle
 94 {
 95     public Semaphore(Int32 initialCount,Int32 maxinumCount);
 96     public Int32 Release();
 97     public Int32 Release(Int32 releaseCount);
 98 }
 99 
100 //互斥體構造,內部維護一個遞歸計數，可以實現遞歸鎖
101 public sealed class Mutex:WaitHandle
102 {
103     public Mutex ();
104     public void ReleaseMutex();
105 }
106 
107 //事件構造，信號量構造，互斥體構造均可以簡單的實現自旋鎖
108 public class SimpleSpinlock
109 {
110     private readonly Mutex m_lock=new Mutex();//針對互斥體構造
111     //private readonly Semaphore m_lock=new Semaphore();//針對信號量構造
112     //private readonly AutoResetEvent m_lock=new AutoResetEvent(true);//針對事件構造
113     public void Enter()
114     {
115         m_lock.WaitOne();
116     }
117     public void Leave()
118     {
119         m_lock.ReleaseMutex();//針對互斥體構造
120         //m_lock.Release(1);//針對信號量構造
121         //m_lock.Set();//針對事件構造
122     }
123 }