C++ Programmer's Cookbook

關鍵節 (Critical Seciton) 與 mutex 的功能類似，但它只能由同一進程中的線程使用。關鍵節可以防止共享資源被同時訪問。

進程負責為關鍵節分配內存空間，關鍵節實際上是一個CRITICAL_SECTION型的變量，它一次只能被一個線程擁有。在線程使用關鍵節之前，必須調用InitializeCriticalSection函數將其初始化。如果線程中有一段關鍵的代碼不希望被別的線程中斷，那么可以調用EnterCriticalSection函數來申請關鍵節的所有權，在運行完關鍵代碼后再用LeaveCriticalSection函數來釋放所有權。如果在調用EnterCriticalSection時關鍵節對象已被另一個線程擁有，那么該函數將無限期等待所有權。

利用互鎖變量可以建立簡單有效的同步機制。使用函數InterlockedIncrement和InterlockedDecrement可以增加或減少多個線程共享的一個32位變量的值，并且可以檢查結果是否為0。線程不必擔心會被其它線程中斷而導致錯誤。如果變量位于共享內存中，那么不同進程中的線程也可以使用這種機制。

LONG InterlockedExchangeAdd(
   PLONG plAddend,
   LONG Increment);

這是個最簡單的函數了。只需調用這個函數，傳遞一個長變量地址，并指明將這個值遞增多少即可。但是這個函數能夠保證值的遞增以原子操作方式來完成。

LONG InterlockedExchange(PLONG plTarget,
LONG lValue);
PVOID InterlockedExchangePointer(PVOID* ppvTarget,
PVOID pvValue);

I n t e r l o c k e d E x c h a n g e和I n t e r l o c k e d E x c h a n g e P o i n t e r能夠以原子操作方式用第二個參數中傳遞的值來取代第一個參數中傳遞的當前值。

                                    ------------------------------以上為用戶方式同步,以下為內核方式同步---------------------------------

等待函數

等待函數可使線程自愿進入等待狀態，直到一個特定的內核對象變為已通知狀態為止。

DWORD WaitForSingleObject(HANDLE hObject,
   DWORD dwMilliseconds);

函數Wa i t F o r M u l t i p l e O b j e c t s與Wa i t F o r S i n g l e O b j e c t函數很相似，區別在于它允許調用線程同時查看若干個內核對象的已通知狀態：

DWORD WaitForMultipleObjects(DWORD dwCount,
CONST HANDLE* phObjects,
BOOL fWaitAll,
DWORD dwMilliseconds);

同步對象

同步對象用來協調多線程的執行，它可以被多個線程共享。線程的等待函數用同步對象的句柄作為參數，同步對象應該是所有要使用的線程都能訪問到的。同步對象的狀態要么是有信號的，要么是無信號的。同步對象主要有三種：事件、 mutex 和信號燈。

事件對象 (Event) 是最簡單的同步對象，它包括有信號和無信號兩種狀態。在線程訪問某一資源之前，也許需要等待某一事件的發生，這時用事件對象最合適。例如，只有在通信端口緩沖區收到數據后，監視線程才被激活。

事件對象是用 CreateEvent 函數建立的。該函數可以指定事件對象的種類和事件的初始狀態。如果是手工重置事件，那么它總是保持有信號狀態，直到用 ResetEvent 函數重置成無信號的事件。如果是自動重置事件，那么它的狀態在單個等待線程釋放后會自動變為無信號的。用 SetEvent 可以把事件對象設置成有信號狀態。在建立事件時，可以為對象起個名字，這樣其它進程中的線程可以用 OpenEvent 函數打開指定名字的事件對象句柄。

mutex對象的狀態在它不被任何線程擁有時是有信號的，而當它被擁有時則是無信號的。mutex對象很適合用來協調多個線程對共享資源的互斥訪問(mutually exclusive)。

線程用 CreateMutex 函數來建立 mutex 對象，在建立 mutex 時，可以為對象起個名字，這樣其它進程中的線程可以用 OpenMutex 函數打開指定名字的 mutex 對象句柄。在完成對共享資源的訪問后，線程可以調用 ReleaseMutex 來釋放 mutex ，以便讓別的線程能訪問共享資源。如果線程終止而不釋放 mutex ，則認為該 mutex 被廢棄。

信號燈對象維護一個從 0 開始的計數，在計數值大于 0 時對象是有信號的，而在計數值為 0 時則是無信號的。信號燈對象可用來限制對共享資源進行訪問的線程數量。線程用 CreateSemaphore 函數來建立信號燈對象，在調用該函數時，可以指定對象的初始計數和最大計數。在建立信號燈時也可以為對象起個名字，別的進程中的線程可以用 OpenSemaphore 函數打開指定名字的信號燈句柄。

一般把信號燈的初始計數設置成最大值。每次當信號燈有信號使等待函數返回時，信號燈計數就會減 1 ，而調用 ReleaseSemaphore 可以增加信號燈的計數。計數值越小就表明訪問共享資源的程序越多。

可用于同步的對象

// Create a global handle to a manual-reset, nonsignaled event.
HANDLE g_hEvent;
int WINAPI WinMain(...)
{
//Create the manual-reset, nonsignaled event.
g_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
//Spawn 3 new threads.
HANDLE hThread[3];
DWORD dwThreadID;
hThread[0] = _beginthreadex(NULL, 0, WordCount, NULL, 0, &dwThreadID);
hThread[1] = _beginthreadex(NULL, 0, SpellCheck, NULL, 0, &dwThreadID);
hThread[2] = _beginthreadex(NULL, 0, GrammarCheck, NULL, 0, &dwThreadID);
OpenFileAndReadContentsIntoMemory(...);
//Allow all 3 threads to access the memory.
SetEvent(g_hEvent);
...
}
DWORD WINAPI WordCount(PVOID pvParam)
{
//Wait until the file's data is in memory.
WaitForSingleObject(g_hEvent, INFINITE);
//Access the memory block.
...
return(0);
}
DWORD WINAPI SpellCheck(PVOID pvParam)
{
//Wait until the file's data is in memory.
WaitForSingleObject(g_hEvent, INFINITE);
//Access the memory block.
...
return(0);
}
DWORD WINAPI GrammarCheck(PVOID pvParam)
{
//Wait until the file's data is in memory.
WaitForSingleObject(g_hEvent, INFINITE);
//Access the memory block.
...
return(0);
}

DWORD WINAPI WordCount(PVOID pvParam)
{
//Wait until the file's data is in memory.
WaitForSingleObject(g_hEvent, INFINITE);
//Access the memory block.
...
SetEvent(g_hEvent);
return(0);
}
DWORD WINAPI SpellCheck(PVOID pvParam)
{
//Wait until the file's data is in memory.
WaitForSingleObject(g_hEvent, INFINITE);
//Access the memory block.
...
SetEvent(g_hEvent);
return(0);
}
DWORD WINAPI GrammarCheck(PVOID pvParam)
{
//Wait until the file's data is in memory.
WaitForSingleObject(g_hEvent, INFINITE);
//Access the memory block.
...
SetEvent(g_hEvent);
return(0);
}

等待定時器是在某個時間或按規定的間隔時間發出自己的信號通知的內核對象。它們通常用來在某個時間執行某個操作。

若要創建等待定時器，只需要調用C r e a t e Wa i t a b l e Ti m e r函數：

HANDLE CreateWaitableTimer(
PSECURITY_ATTRIBUTES psa,
BOOL fManualReset,
PCTSTR pszName);

HANDLE OpenWaitableTimer(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
PCTSTR pszName);

等待定時器對象總是在未通知狀態中創建。必須調用S e t Wa i t a b l e Ti m e r函數來告訴定時器你想在何時讓它成為已通知狀態：

BOOL SetWaitableTimer(
HANDLE hTimer,
const LARGE_INTEGER *pDueTime,
LONG lPeriod,
PTIMERAPCROUTINE pfnCompletionRoutine,
PVOID pvArgToCompletionRoutine,
BOOL fResume);

BOOL CancelWaitableTimer(HANDLE hTimer);

HANDLE CreateSemaphore(
PSECURITY_ATTRIBUTE psa,
LONG lInitialCount,
LONG lMaximumCount,
PCTSTR pszName);

HANDLE OpenSemaphore(
DWORD fdwAccess,
BOOL bInheritHandle,
PCTSTR pszName);

通過調用R e l e a s e S e m a p h o r e函數，線程就能夠對信標的當前資源數量進行遞增：

BOOL ReleaseSemaphore(
HANDLE hsem,
LONG lReleaseCount,
PLONG plPreviousCount);

互斥對象（m u t e x）內核對象能夠確保線程擁有對單個資源的互斥訪問權。
互斥對象有許多用途，屬于最常用的內核對象之一。通常來說，它們用于保護由多個線程訪問的內存塊。如果多個線程要同時訪問內存塊，內存塊中的數據就可能遭到破壞。互斥對象能夠保證訪問內存塊的任何線程擁有對該內存塊的獨占訪問權，這樣就能夠保證數據的完整性。

互斥對象的使用規則如下：

• 如果線程I D是0（這是個無效I D），互斥對象不被任何線程所擁有，并且發出該互斥對象的通知信號。

• 如果I D是個非0數字，那么一個線程就擁有互斥對象，并且不發出該互斥對象的通知信號。

• 與所有其他內核對象不同， 互斥對象在操作系統中擁有特殊的代碼，允許它們違反正常的規則（后面將要介紹這個異常情況）。

若要使用互斥對象，必須有一個進程首先調用C r e a t e M u t e x，以便創建互斥對象：

HANDLE CreateMutex(
PSECURITY_ATTRIBUTES psa,
BOOL fInitialOwner,
PCTSTR pszName);

通過調用O p e n M u t e x，另一個進程可以獲得它自己進程與現有互斥對象相關的句柄：

HANDLE OpenMutex(
DWORD fdwAccess,
BOOL bInheritHandle,
PCTSTR pszName);

一旦線程成功地等待到一個互斥對象，該線程就知道它已經擁有對受保護資源的獨占訪問權。試圖訪問該資源的任何其他線程（通過等待相同的互斥對象）均被置于等待狀態中。當目前擁有對資源的訪問權的線程不再需要它的訪問權時，它必須調用R e l e a s e M u t e x函數來釋放該互斥對象：

BOOL ReleaseMutex(HANDLE hMutex);

該函數將對象的遞歸計數器遞減1。

互斥對象與關鍵代碼段的比較

就等待線程的調度而言，互斥對象與關鍵代碼段之間有著相同的特性。但是它們在其他屬性方面卻各不相同。表9 - 1對它們進行了各方面的比較。

表9-1 互斥對象與關鍵代碼段的比較

DWORD WaitForInputIdle(
HANDLE hProcess,
DWORD dwMilliseconds);

DWORD MsgWaitForMultipleObjects(
DWORD dwCount,
PHANDLE phObjects,
BOOL fWaitAll,
DWORD dwMilliseconds,
DWORD dwWakeMask);
DWORD MsgWaitForMultipleObjectsEx(
DWORD dwCount,
PHANDLE phObjects,
DWORD dwMilliseconds,
DWORD dwWakeMask,
DWORD dwFlags);

BOOL WaitForDebugEvent(
PDEBUG_EVENT pde,
DWORD dwMilliseconds);

DWORD SingleObjectAndWait(
HANDLE hObjectToSignal,
HANDLE hObjectToWaitOn,
DWORD  dwMilliseconds,
BOOL   fAlertable);