臨界區,互斥量,信號量,事件的區別

(轉)臨界區，互斥量，信號量，事件的區別(線程同步) 收藏

 
四種進程或線程同步互斥的控制方法
1、臨界區:通過對多線程的串行化來訪問公共資源或一段代碼，速度快，適合控制數據訪問。
2、互斥量:爲協調共同對一個共享資源的單獨訪問而設計的。
3、信號量:爲控制一個具有有限數量用戶資源而設計。
4、事 件:用來通知線程有一些事件已發生，從而啓動後繼任務的開始。
 
臨界區（Critical Section）
 
 
保證在某一時刻只有一個線程能訪問數據的簡便辦法。在任意時刻只允許一個線程對共享資源進行訪問。如果有多個線程試圖同時訪問臨界區，那麼在有一個線 程進入後其他所有試圖訪問此臨界區的線程將被掛起，並一直持續到進入臨界區的線程離開。臨界區在被釋放後，其他線程可以繼續搶佔，並以此達到用原子方式操 作共享資源的目的。
臨界區包含兩個操作原語：
EnterCriticalSection（） 進入臨界區
LeaveCriticalSection（） 離開臨界區
EnterCriticalSection（）語句執行後代碼將進入臨界區以後無論發生什麼，必須確保與之匹配的 LeaveCriticalSection（）都能夠被執行到。否則臨界區保護的共享資源將永遠不會被釋放。雖然臨界區同步速度很快，但卻只能用來同步本 進程內的線程，而不可用來同步多個進程中的線程。
MFC提供了很多功能完備的類，我用MFC實現了臨界區。MFC爲臨界區提供有一個CCriticalSection類，使用該類進行線程同步處理是 非常簡單的。只需在線程函數中用CCriticalSection類成員函數Lock（）和UnLock（）標定出被保護代碼片段即可。Lock（）後代 碼用到的資源自動被視爲臨界區內的資源被保護。UnLock後別的線程才能訪問這些資源。
互斥量（Mutex）
 
互斥量跟臨界區很相似，只有擁有互斥對象的線程才具有訪問資源的權限，由於互斥對象只有一個，因此就決定了任何情況下此共享資源都不會同時被多個線程 所訪問。當前佔據資源的線程在任務處理完後應將擁有的互斥對象交出，以便其他線程在獲得後得以訪問資源。互斥量比臨界區複雜。因爲使用互斥不僅僅能夠在同 一應用程序不同線程中實現資源的安全共享，而且可以在不同應用程序的線程之間實現對資源的安全共享。
 
互斥量包含的幾個操作原語：
CreateMutex（） 創建一個互斥量
OpenMutex（） 打開一個互斥量
ReleaseMutex（） 釋放互斥量
WaitForMultipleObjects（） 等待互斥量對象
 
同樣MFC爲互斥量提供有一個CMutex類。使用CMutex類實現互斥量操作非常簡單，但是要特別注意對CMutex的構造函數的調用
CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL)
不用的參數不能亂填，亂填會出現一些意想不到的運行結果。
 
信號量（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（） 等待信號量
事件（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。
 
總結：
1． 互斥量與臨界區的作用非常相似，但互斥量是可以命名的，也就是說它可以跨越進程使用。所以創建互斥量需要的資源更多，所以如果只爲了在進程內部是用的話使 用臨界區會帶來速度上的優勢並能夠減少資源佔用量。因爲互斥量是跨進程的互斥量一旦被創建，就可以通過名字打開它。
2． 互斥量（Mutex），信號燈（Semaphore），事件（Event）都可以被跨越進程使用來進行同步數據操作，而其他的對象與數據同步操作無關，但 對於進程和線程來講，如果進程和線程在運行狀態則爲無信號狀態，在退出後爲有信號狀態。所以可以使用WaitForSingleObject來等待進程和 線程退出。
3． 通過互斥量可以指定資源被獨佔的方式使用，但如果有下面一種情況通過互斥量就無法處理，比如現在一位用戶購買了一份三個併發訪問許可的數據庫系統，可以根 據用戶購買的訪問許可數量來決定有多少個線程/進程能同時進行數據庫操作，這時候如果利用互斥量就沒有辦法完成這個要求，信號燈對象可以說是一種資源計數 器。
 
1、  Event
用事件（Event）來同步線程是最具彈性的了。一個事件有兩種狀態：激發狀態和未激發狀態。也稱有信號狀態和無信號狀態。事件又分兩種類型：手動重置事件和自動重置事件。手動重置事件被設置爲激發狀態後，會喚醒所有等待的線程，而且一直保持爲激發狀態，直到程序重新把它設置爲未激發狀態。自動重置事件被設置爲激發狀態後，會喚醒“一個”等待中的線程，然後自動恢復爲未激發狀態。所以用自動重置事件來同步兩個線程比較理想。MFC中對應的類爲CEvent.。CEvent的構造函數默認創建一個自動重置的事件，而且處於未激發狀態。共有三個函數來改變事件的狀態:SetEvent,ResetEvent和PulseEvent。用事件來同步線程是一種比較理想的做法，但在實際的使用過程中要注意的是，對自動重置事件調用SetEvent和PulseEvent有可能會引起死鎖，必須小心。
2、  Critical Section
使用臨界區域的第一個忠告就是不要長時間鎖住一份資源。這裏的長時間是相對的，視不同程序而定。對一些控制軟件來說，可能是數毫秒，但是對另外一些程序來說，可以長達數分鐘。但進入臨界區後必須儘快地離開，釋放資源。如果不釋放的話，會如何？答案是不會怎樣。如果是主線程（GUI線程）要進入一個沒有被釋放的臨界區，呵呵，程序就會掛了！臨界區域的一個缺點就是：Critical Section不是一個核心對象，無法獲知進入臨界區的線程是生是死，如果進入臨界區的線程掛了，沒有釋放臨界資源，系統無法獲知，而且沒有辦法釋放該臨界資源。這個缺點在互斥器(Mutex)中得到了彌補。Critical Section在MFC中的相應實現類是CcriticalSection。CcriticalSection：：Lock()進入臨界區，CcriticalSection：：UnLock()離開臨界區。
3、  Mutex
互斥器的功能和臨界區域很相似。區別是：Mutex所花費的時間比Critical Section多的多，但是Mutex是核心對象(Event、Semaphore也是)，可以跨進程使用，而且等待一個被鎖住的Mutex可以設定TIMEOUT，不會像Critical Section那樣無法得知臨界區域的情況，而一直死等。MFC中的對應類爲CMutex。Win32函數有：創建互斥體CreateMutex() ，打開互斥體OpenMutex()，釋放互斥體ReleaseMutex()。Mutex的擁有權並非屬於那個產生它的線程，而是最後那個對此Mutex進行等待操作（WaitForSingleObject等等）並且尚未進行ReleaseMutex()操作的線程。線程擁有Mutex就好像進入Critical Section一樣，一次只能有一個線程擁有該Mutex。如果一個擁有Mutex的線程在返回之前沒有調用ReleaseMutex()，那麼這個Mutex就被捨棄了，但是當其他線程等待(WaitForSingleObject等)這個Mutex時，仍能返回，並得到一個WAIT_ABANDONED_0返回值。能夠知道一個Mutex被捨棄是Mutex特有的。
4、  Semaphore
信號量是最具歷史的同步機制。信號量是解決producer/consumer問題的關鍵要素。對應的MFC類是Csemaphore。Win32函數CreateSemaphore（）用來產生信號量。ReleaseSemaphore（）用來解除鎖定。Semaphore的現值代表的意義是目前可用的資源數，如果Semaphore的現值爲1，表示還有一個鎖定動作可以成功。如果現值爲5，就表示還有五個鎖定動作可以成功。當調用Wait…等函數要求鎖定，如果Semaphore現值不爲0，Wait…馬上返回，資源數減1。當調用ReleaseSemaphore（）資源數加1，當時不會超過初始設定的資源總數。
 
4 種進程或線程同步互斥的控制方法
很想整理一下自己對進程線程同步互斥的理解。正巧週六一個剛剛回到學校的同學請客吃飯。在吃飯的過程中，有兩個同學，爲了一個問題爭論的面紅耳赤。一個認爲.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． 通過互斥量可以指定資源被獨佔的方式使用，但如果有下面一種情況通過互斥量就無法處理，比如現在一位用戶購買了一份三個併發訪問許可的數據庫系統，可以根據用戶購買的訪問許可數量來決定有多少個線程/進程能同時進行數據庫操作，這時候如果利用互斥量就沒有辦法完成這個要求，信號燈對象可以說是一種資源計數器。
　　 疑問：
　　 在 Linux 上，有兩類信號量。第一類是由 semget/semop/semctl API 定義的信號量的 SVR4（System V Release 4）版本。第二類是由 sem_init/sem_wait/sem_post/interfaces 定義的 POSIX 接口。 它們具有相同的功能，但接口不同。 在2.4.x內核中，信號量數據結構定義爲(include/asm/semaphore.h)。
 但是在Linux中沒有對互斥量的具體提法，只是看到說互斥量是信號量的一種特殊情況，當信號量的最大資源數=1同時可以訪問共享資源的線程數=1 就是互斥量了。臨界區的定義也比較模糊。沒有找到用事件處理線程/進程同步互斥的操作的相關資料。在Linux下用GCC/G++編譯標準C++代碼，信號量的操作幾乎和Windows下VC7的編程一樣，不用改多少就順利移植了，可是互斥量，事件，臨界區的Linux移植沒有成功。
 
　　 本文所有事例程序在WindowsXp Sp2 + VC7 下編譯通過
臨界區是一個進程裏的所有線程同步的最好辦法，他不是系統級的，只是進程級的，也就是說他可能利用進程內的一些標誌來保證該進程內的線程同步，據Richter說是一個記數循環；臨界區只能在同一進程內使用；臨界區只能無限期等待，不過2k增加了TryEnterCriticalSection函數實現0時間等待。
互斥則是保證多進程間的線程同步，他是利用系統內核對象來保證同步的。由於系統內核對象可以是有名字的，因此多個進程間可以利用這個有名字的內核對象保證系統資源的線程安全性。互斥量是Win32 內核對象，由操作系統負責管理；互斥量可以使用WaitForSingleObject實現無限等待，0時間等待和任意時間等待。
1. 臨界區
臨界區是一種最直接的線程同步方式。所謂臨界區，就是一次只能由一個線程來執行的一段代碼。如果把初始化數組的代碼放在臨界區內，另一個線程在第一個線程處理完之前是不會被執行的。在使用臨界區之前，必須使用InitializeCriticalSection()過程來初始化它。
在第一個線程調用了EnterCriticalSection()之後，所有別的線程就不能再進入代碼塊。下一個線程要等第一個線程調用LeaveCriticalSection()後才能被喚醒。
2. 互斥
互斥非常類似於臨界區，除了兩個關鍵的區別：首先，互斥可用於跨進程的線程同步。其次，互斥能被賦予一個字符串名字，並且通過引用此名字創建現有互斥對象的附加句柄。
提示：臨界區與事件對象(比如互斥對象)的最大的區別是在性能上。臨界區在沒有線程衝突時，要用10 ~ 15個時間片，而事件對象由於涉及到系統內核要用400~600個時間片。
當一個互斥對象不再被一個線程所擁有,它就處於發信號狀態。此時首先調用WaitForSingleObject()函數的線程就成爲該互斥對象的擁有者，此互斥對象設爲不發信號狀態。當線程調用ReleaseMutex()函數並傳遞一個互斥對象的句柄作爲參數時，這種擁有關係就被解除，互斥對象重新進入發信號狀態。
可以調用函數CreateMutex()來創建一個互斥量。當使用完互斥對象時，應當調用CloseHandle()來關閉它。
3. 信號量
另一種使線程同步的技術是使用信號量對象。它是在互斥的基礎上建立的，但信號量增加了資源計數的功能，預定數目的線程允許同時進入要同步的代碼。可以用CreateSemaphore()來創建一個信號量對象，
因爲只允許一個線程進入要同步的代碼，所以信號量的最大計數值(lMaximumCount)要設爲1。ReleaseSemaphore()函數將使信號量對象的計數加1；
記住，最後一定要調用CloseHandle()函數來釋放由CreateSemaphore()創建的信號量對象的句柄。
★★★WaitForSingleObject函數的返值：
WAIT_ABANDONED指定的對象是互斥對象，並且擁有這個互斥對象的線程在沒有釋放此對象之前就已終止。此時就稱互斥對象被拋棄。這種情況下，這個互斥對象歸當前線程所有，並把它設爲非發信號狀態；
WAIT_OBJECT_0 指定的對象處於發信號狀態；
WAIT_TIMEOUT等待的時間已過，對象仍然是非發信號狀態；