C#多執行緒程式設計例項

　　它首先進入臨界區判斷當前活動執行緒的數目，如果當前有活動執行緒存在，不管是寫執行緒還是讀執行緒（m_nActive），執行緒將等待指定的時間並且等待的寫入執行緒數目加1，否則執行緒擁有寫的許可權。

　　釋放閱讀鎖的函式原型為：public void ReleaseReaderLock()。函式定義如下：

public void ReleaseReaderLock()

{   
　　System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot(m_strThreadSlotName );
　　LockFlags flag = (LockFlags)Thread.GetData( slot );
　　if( flag == LockFlags.None )

　　{   return;
　　}

　　bool bReader = true;  switch( flag )
　　{   
　　　　case LockFlags.None:   
　　　　break;
　　　　case LockFlags.Writer:
　　　　bReader = false;
　　　　break;
　　}

　　if( !bReader )
　　　return;
　　Thread.SetData( slot, LockFlags.None );
　　m_mutex.WaitOne();
　　AutoResetEvent autoresetevent = null;
　　this.m_nActive --;
　　if( this.m_nActive == 0 )
　　{    if( this.m_nWaitingReaders > 0 )

　　　　{   
　　　　　　m_nActive ++ ;   
　　　　　　m_nWaitingReaders --;   
　　　　　　autoresetevent = this.m_aeReaders;
　　　　}   
　　　　else if( this.m_nWaitingWriters > 0)   
　　　　{  
　　　　　　m_nWaitingWriters--;

　　　　　　m_nActive --;

　　　　　　autoresetevent = this.m_aeWriters ;

　　　　}
    }

　　m_mutex.ReleaseMutex();   
　　if( autoresetevent != null )   
　　　autoresetevent.Set();   
}

　　釋放閱讀鎖時，首先判斷當前執行緒是否擁有閱讀鎖（通過執行緒區域性儲存的標誌），然後判斷是否有等待的閱讀執行緒，如果有，先將當前活動執行緒加1，等待閱讀執行緒數目減1，然後置事件為有訊號。如果沒有等待的閱讀執行緒，判斷是否有等待的寫入執行緒，如果有則活動執行緒數目減1，等待的寫入執行緒數目減1。釋放寫入鎖與釋放閱讀鎖的過程基本一致，可以參看原始碼。

　　注意在程式中，釋放鎖時，只會喚醒一個閱讀程式，這是因為使用AutoResetEvent的原歷，讀者可自行將其改成ManualResetEvent，同時喚醒多個閱讀程式，此時應令m_nActive等於整個等待的閱讀執行緒數目。

　　測試

　　測試程式取自.Net FrameSDK中的一個例子，只是稍做修改。測試程式如下，

using System;   
using System.Threading;  
using MyThreading;   
class Resource {   
　　myReaderWriterLock rwl = new myReaderWriterLock();   
　　public void Read(Int32 threadNum) {   
　　　　rwl.AcquireReaderLock(Timeout.Infinite);

　　　　try {
　　　　　   Console.WriteLine("Start Resource reading (Thread={0})", threadNum);

　　　　　　Thread.Sleep(250);

　　　　　　Console.WriteLine("Stop Resource reading (Thread={0})", threadNum);
　　　　}

　　　　finally {  rwl.ReleaseReaderLock();

　　　　}
　　}

　　public void Write(Int32 threadNum) {   
　　　　rwl.AcquireWriterLock(Timeout.Infinite);   
　　　　try {   
　　　　　　Console.WriteLine("Start Resource writing (Thread={0})", threadNum);
　　　　　　Thread.Sleep(750);
　　　　　　Console.WriteLine("Stop Resource writing (Thread={0})", threadNum);
　　　　}

　　　　finally {  rwl.ReleaseWriterLock();   
　　　　}
   }   
}   
class App {

　　static Int32 numAsyncOps = 20;   
　　static AutoResetEvent asyncOpsAreDone = new AutoResetEvent(false);   
　　static Resource res = new Resource();      
　　public static void Main() {   
　　　　for (Int32 threadNum = 0; threadNum < 20; threadNum++) {   
　　　　　　ThreadPool.QueueUserWorkItem(new WaitCallback(UpdateResource), threadNum);   
　　　　}

　　　　asyncOpsAreDone.WaitOne();
　　　　Console.WriteLine("All operations have completed.");   
　　　　Console.ReadLine();   
　　}

　　// The callback method's signature MUST match that of a System.Threading.TimerCallback   
　　// delegate (it takes an Object parameter and returns void)  
　　static void UpdateResource(Object state) {   
　　　　Int32 threadNum = (Int32) state;   
　　　　if ((threadNum % 2) != 0) res.Read(threadNum);   
　　　　else res.Write(threadNum);   
　　　　if (Interlocked.Decrement(ref numAsyncOps) == 0)   
　　　　　　asyncOpsAreDone.Set();   
　　}   
}