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