ASP.net:四種進程或線程同步互斥的控制方法

　靜態方法如果沒有使用靜態變數，則沒有安全執行緒問題。

　　為什麼呢?因為靜態方法內聲明的變數，每個線程調用時，都會新建立一份，而不會共用一個儲存單元。每個線程都會建立自己的一份，因此不會有安全執行緒問題

　　注意，靜態變數，由於是在類載入時佔用一個儲存區，每個線程都是共用這個儲存區的，所以如果在靜態方法裡使用了靜態變數，這就會有安全執行緒問題!

　　目前流行的進程線程同步互斥的控制機制，其實是由最原始最基本的4種方法實現的。由這4種方法組合最佳化就有了.Net和Java下靈活多變的，編程簡便的線程進程式控制制手段。 

　　這4種方法具體定義如下 在《作業系統教程》ISBN 7-5053-6193-7 一書中能找到更加周詳的解釋 

　　1臨界區:通過對多線程的序列化來訪問公用資源或一段代碼，速度快，適合控制資料訪問。 

　　2互斥量:為協調一起對一個共用資源的獨立訪問而設計的。 

　　3訊號量:為控制一個具有有限數量使用者資源而設計。 

　　4事 件:用來通知線程有一些事件已發生，從而啟動後繼任務的開始。
  
  　　臨界區（Critical Section） 

　　確保在某一時刻只有一個線程能訪問資料的簡便辦法。在任意時刻只允許一個線程對共用資源進行訪問。如果有多個線程試圖同時訪問臨界區，那麼在有一個線程進入後其他所有試圖訪問此臨界區的線程將被掛起，並一直持續到進入臨界區的線程離開。臨界區在被釋放後，其他線程能繼續搶佔，並以此達到用原子方式操作共用資源的目的。 

　　臨界區包含兩個操作原語： EnterCriticalSection（） 進入臨界區 LeaveCriticalSection（） 離開臨界區 

　　EnterCriticalSection（）語句執行後代碼將進入臨界區以後無論發生什麼，必須確保和之匹配的LeaveCriticalSection（）都能夠被執行到。否則臨界區保護的共用資源將永遠不會被釋放。雖然臨界區同步速度非常快，但卻只能用來同步本進程內的線程，而不可用來同步多個進程中的線程。 

　　MFC提供了非常多功能完備的類，我用MFC實現了臨界區。MFC為臨界區提供有一個CCriticalSection類，使用該類進行線程同步處理是非常簡單的。只需線上程函數中用CCriticalSection類成員函數Lock（）和UnLock（）標定出被保護程式碼片段即可。Lock（）後代碼用到的資源自動被視為臨界區內的資源被保護。UnLock後別的線程才能訪問這些資源。

  //CriticalSection
  CCriticalSection global_CriticalSection;
  
  // 共用資源
  char global_Array[256];
  
  //初始化共用資源
  void InitializeArray()
  {
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=I;
   }
  }
  
  //寫線程
  UINT Global_ThreadWrite(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   //進入臨界區
  global_CriticalSection.Lock();
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=W;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   } 

　//離開臨界區
   global_CriticalSection.Unlock();
   return 0;
  }
  
  //刪除線程
  UINT Global_ThreadDelete(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   //進入臨界區
   global_CriticalSection.Lock();
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=D;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
  
　//離開臨界區
   global_CriticalSection.Unlock();
   return 0;
  }
  
  //建立線程並啟動線程
  void CCriticalSectionsDlg::OnBnClickedButtonLock()
  {
   //Start the first Thread
   CWinThread *ptrWrite = AfxBeginThread(Global_ThreadWrite,
   &m_Write,
   THREAD_PRIORITY_NORMAL,
   0,
   CREATE_SUSPENDED);
   ptrWrite->ResumeThread();
   　
   //Start the second Thread
   CWinThread *ptrDelete = AfxBeginThread(Global_ThreadDelete,
   &m_Delete,
   THREAD_PRIORITY_NORMAL,
   0,
   CREATE_SUSPENDED);
   ptrDelete->ResumeThread();
  } 

　　在測試程式中，Lock UnLock兩個按鈕分別實現，在有臨界區保護共用資源的執行狀態，和沒有臨界區保護共用資源的執行狀態。 

　　程式運行結果

　　互斥量（Mutex） 
   
　　互斥量跟臨界區非常相似，只有擁有互斥對象的線程才具有訪問資源的許可權，由於互斥對象只有一個，因此就決定了所有情況下此共用資源都不會同時被多個線程所訪問。當前佔據資源的線程在任務處理完後應將擁有的互斥對象交出，以便其他線程在獲得後得以訪問資源。互斥量比臨界區複雜。因為使用互斥不僅僅能夠在同一應用程式不同線程中實現資源的安全共用，而且能在不同應用程式的線程之間實現對資源的安全共用。
  
  　　互斥量包含的幾個操作原語：
  　　CreateMutex（） 建立一個互斥量
  　　OpenMutex（） 開啟一個互斥量
  　　ReleaseMutex（） 釋放互斥量
  　　WaitForMultipleObjects（） 等待互斥量對象 
   
　　同樣MFC為互斥量提供有一個CMutex類。使用CMutex類實現互斥量操作非常簡單，不過要特別注意對CMutex的建構函式的調用

　　CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL) 

　不用的參數不能亂填，亂填會出現一些意想不到的運行結果。

  //建立互斥量
  CMutex global_Mutex(0,0,0);
  
  // 共用資源
  char global_Array[256];
  
  void InitializeArray()
  {
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=I;
   }
  }
  UINT Global_ThreadWrite(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   global_Mutex.Lock();
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=W;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
   global_Mutex.Unlock();
   return 0;
  }
  
  UINT Global_ThreadDelete(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   global_Mutex.Lock();
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=D;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
   global_Mutex.Unlock();
   return 0;
  } 

　　同樣在測試程式中，Lock UnLock兩個按鈕分別實現，在有互斥量保護共用資源的執行狀態，和沒有互斥量保護共用資源的執行狀態。 

　　程式運行結果 

　　訊號量（Semaphores） 

　　訊號量對象對線程的同步方式和前面幾種方法不同，訊號允許多個線程同時使用共用資源，這和作業系統中的PV操作相同。他指出了同時訪問共用資源的線程最大數目。他允許多個線程在同一時刻訪問同一資源，不過需要限制在同一時刻訪問此資源的最大線程數目。在用CreateSemaphore（）建立訊號量時即要同時指出允許的最大資源計數和當前可用資源計數。一般是將當前可用資源計數設定為最大資源計數，每增加一個線程對共用資源的訪問，當前可用資源計數就會減1，只要當前可用資源計數是大於0的，就能發出訊號量訊號。不過當前可用計數減小到0時則說明當前佔用資源的線程數已達到了所允許的最大數目，不能在允許其他線程的進入，此時的訊號量訊號將無法發出。線程在處理完共用資源後，應在離開的同時通過ReleaseSemaphore（）函數將當前可用資源計數加1。在所有時候當前可用資源計數決不可能大於最大資源計數。 

　　PV操作及訊號量的概念都是由荷蘭科學家E.W.Dijkstra提出的。訊號量S是個整數，S大於等於零時代表可供並發進程使用的資源實體數，但S小於零時則表示正在等待使用共用資源的進程數。 

　　 P操作申請資源：
  　　（1）S減1；
  　　（2）若S減1後仍大於等於零，則進程繼續執行；
  　　（3）若S減1後小於零，則該進程被阻塞後進入和該訊號相對應的隊列中，然後轉入進程調度。 
　　
　　V操作 釋放資源：
  　　（1）S加1；
  　　（2）若相加結果大於零，則進程繼續執行；
  　　（3）若相加結果小於等於零，則從該訊號的等待隊列中喚醒一個等待進程，然後再返回原進程繼續執行或轉入進程調度。
  
  　　訊號量包含的幾個操作原語：
  　　CreateSemaphore（） 建立一個訊號量
  　　OpenSemaphore（） 開啟一個訊號量
  　　ReleaseSemaphore（） 釋放訊號量
  　　WaitForSingleObject（） 等待訊號量

  //訊號量控制代碼
  HANDLE global_Semephore;
  
  // 共用資源
  char global_Array[256];
  void InitializeArray()
  {
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=I;
   }
  }
  
　//線程1
  UINT Global_ThreadOne(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   //等待對共用資源請求被通過 等於 P操作
  WaitForSingleObject(global_Semephore, INFINITE);
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=O;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
 
  //釋放共用資源 等於 V操作
   ReleaseSemaphore(global_Semephore, 1, NULL);
   return 0;
  }
  
  UINT Global_ThreadTwo(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   WaitForSingleObject(global_Semephore, INFINITE);
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=T;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
   ReleaseSemaphore(global_Semephore, 1, NULL);
   return 0;
  }
  
  UINT Global_ThreadThree(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   WaitForSingleObject(global_Semephore, INFINITE);
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=H;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
   ReleaseSemaphore(global_Semephore, 1, NULL);
   return 0;
  }
  
  void CSemaphoreDlg::OnBnClickedButtonOne()
  {

   //設定訊號量 1 個資源 1同時只能有一個線程訪問
   global_Semephore= CreateSemaphore(NULL, 1, 1, NULL);
   this->StartThread();
 
  // TODO: Add your control notification handler code here
  }
  
  void CSemaphoreDlg::OnBnClickedButtonTwo()
  {

   //設定訊號量 2 個資源 2 同時只能有兩個線程訪問
   global_Semephore= CreateSemaphore(NULL, 2, 2, NULL);
   this->StartThread();

   // TODO: Add your control notification handler code here
  }
  
  void CSemaphoreDlg::OnBnClickedButtonThree()
  {

  //設定訊號量 3 個資源 3 同時只能有三個線程訪問
   global_Semephore= CreateSemaphore(NULL, 3, 3, NULL);
   this->StartThread(); 
 
  // TODO: Add your control notification handler code here
  } 

　　訊號量的使用特點使其更適用於對Socket（通訊端）程式中線程的同步。例如，網路上的HTTP伺服器要對同一時間內訪問同一頁面的使用者數加以限制，這時能為每一個使用者對伺服器的頁面請求設定一個線程，而頁面則是待保護的共用資源，通過使用訊號量對線程的同步作用能確保在任一時刻無論有多少使用者對某一頁面進行訪問，只有不大於設定的最大使用者數目的線程能夠進行訪問，而其他的訪問企圖則被掛起，只有在有使用者退出對此頁面的訪問後才有可能進入。 
 
　　程式運行結果 

　　事件（Event） 
   
　　事件對象也能通過通知操作的方式來保持線程的同步。並且能實現不同進程中的線程同步操作。 

　　訊號量包含的幾個操作原語：
  　　CreateEvent（） 建立一個訊號量
  　　OpenEvent（） 開啟一個事件
  　　SetEvent（） 回置事件
  　　WaitForSingleObject（） 等待一個事件
  　　WaitForMultipleObjects（）　等待多個事件 

　　WaitForMultipleObjects 函數原型：
  　　WaitForMultipleObjects（
  　　IN DWORD nCount, // 等待控制代碼數
  　　IN CONST HANDLE *lpHandles, //指向控制代碼數組
  　　IN BOOL bWaitAll, //是否完全等待標誌
  　　IN DWORD dwMilliseconds //等待時間
  　　） 
 
　　參數nCount指定了要等待的核心對象的數目，存放這些核心對象的數組由lpHandles來指向。fWaitAll對指定的這nCount個核心對象的兩種等待方式進行了指定，為TRUE時當所有對象都被通知時函數才會返回，為FALSE則只要其中所有一個得到通知就能返回。dwMilliseconds在這裡的作用和在WaitForSingleObject（）中的作用是完全一致的。如果等待逾時，函數將返回WAIT_TIMEOUT。

  //事件數目組
  HANDLE global_Events[2];
  
  // 共用資源
  char global_Array[256];
  
  void InitializeArray()
  {
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=I;
   }
  }
  
  UINT Global_ThreadOne(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=O;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
 
  //回置事件
   SetEvent(global_Events[0]);
   return 0;
  }
  
  UINT Global_ThreadTwo(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=T;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
 
  //回置事件
   SetEvent(global_Events[1]);
   return 0;
  }
  
  UINT Global_ThreadThree(LPVOID pParam)
  {
   CEdit *ptr=(CEdit *)pParam;
   ptr->SetWindowText("");
 
  //等待兩個事件都被回置
   WaitForMultipleObjects(2, global_Events, true, INFINITE);
   for(int i = 0;i<256;i++)
   {
   global_Array[i]=H;
   ptr->SetWindowText(global_Array);
   Sleep(10);
   }
   return 0;
  }
  void CEventDlg::OnBnClickedButtonStart()
  {
   for (int i = 0; i < 2; i++)
   {
 
  //執行個體化事件
   global_Events[i]=CreateEvent(NULL,false,false,NULL);
   }
   CWinThread *ptrOne = AfxBeginThread(Global_ThreadOne,
   &m_One,
   THREAD_PRIORITY_NORMAL,
   0,
   CREATE_SUSPENDED);
   ptrOne->ResumeThread();
  
   //Start the second Thread
   CWinThread *ptrTwo = AfxBeginThread(Global_ThreadTwo,
   &m_Two,
   THREAD_PRIORITY_NORMAL,
   0,
   CREATE_SUSPENDED);
   ptrTwo->ResumeThread();
  
   //Start the Third Thread
   CWinThread *ptrThree = AfxBeginThread(Global_ThreadThree,
   &m_Three,
   THREAD_PRIORITY_NORMAL,
   0,
   CREATE_SUSPENDED);
   ptrThree->ResumeThread();

   // TODO: Add your control notification handler code here
  } 
 
　　事件能實現不同進程中的線程同步操作，並且能方便的實現多個線程的優先比較等待操作，例如寫多個WaitForSingleObject來代替WaitForMultipleObjects從而使編程更加靈活。 

　　程式運行結果 

　　總結： 

　　1． 互斥量和臨界區的作用非常相似，但互斥量是能命名的，也就是說他能跨越進程使用。所以建立互斥量需要的資源更多，所以如果只為了在進程內部是用的話使用臨界區會帶來速度上的優勢並能夠減少資源佔用量。因為互斥量是跨進程的互斥量一旦被建立，就能通過名字開啟他。 

　　2． 互斥量（Mutex），號誌（Semaphore），事件（Event）都能被跨越進程使用來進行同步資料操作，而其他的對象和資料同步操作無關，但對於進程和線程來講，如果進程和線程在運行狀態則為無訊號狀態，在退出後為有訊號狀態。所以能使用WaitForSingleObject來等待進程和線程退出。 

　　3． 通過互斥量能指定資源被獨佔的方式使用，但如果有下面一種情況通過互斥量就無法處理，比如目前一位使用者購買了一份三個並發訪問許可的資料庫系統，能根據使用者購買的訪問許可數量來決定有多少個線程/進程能同時進行資料庫操作，這時候如果利用互斥量就沒有辦法完成這個需求，號誌對象能說是一種資源計數器。