很想整理一下自己對進程線程同步互斥的理解。正巧周六一個剛剛回到學校的同學請客吃飯。在吃飯的過程中，有兩個同學，為了一個問題爭論的面紅耳赤。一個認為.net下的進程線程控制模型更加合理。一個認為java下的線程池策略比.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． 通過互斥量可以指定資源被獨占的方式使用，但如果有下面一種情況通過互斥量就無法處理，比如現在一位用戶購買了一份三個并發訪問許可的數據庫系統，可以根據用戶購買的訪問許可數量來決定有多少個線程/進程能同時進行數據庫操作，這時候如果利用互斥量就沒有辦法完成這個要求，信號燈對象可以說是一種資源計數器。

最大的網站源碼資源下載站，