C++ Programmer's Cookbook

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

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

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

LONG InterlockedExchangeAdd(
   PLONG plAddend,
   LONG Increment);

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

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能夠以原子操作方式用第二個參數(shù)中傳遞的值來取代第一個參數(shù)中傳遞的當前值。

                                    ------------------------------以上為用戶方式同步,以下為內(nèi)核方式同步---------------------------------

等待函數(shù)

等待函數(shù)可使線程自愿進入等待狀態(tài)，直到一個特定的內(nèi)核對象變?yōu)橐淹ㄖ獱顟B(tài)為止。

DWORD WaitForSingleObject(HANDLE hObject,
   DWORD dwMilliseconds);

函數(shù)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函數(shù)很相似，區(qū)別在于它允許調(diào)用線程同時查看若干個內(nèi)核對象的已通知狀態(tài)：

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

同步對象

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

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

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

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

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

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

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

可用于同步的對象

// 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);
}

等待定時器是在某個時間或按規(guī)定的間隔時間發(fā)出自己的信號通知的內(nèi)核對象。它們通常用來在某個時間執(zhí)行某個操作。

若要創(chuàng)建等待定時器，只需要調(diào)用C r e a t e Wa i t a b l e Ti m e r函數(shù)：

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

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

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

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);

通過調(diào)用R e l e a s e S e m a p h o r e函數(shù)，線程就能夠?qū)π艠说漠斍百Y源數(shù)量進行遞增：

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

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

互斥對象的使用規(guī)則如下：

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

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

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

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

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

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

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

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

BOOL ReleaseMutex(HANDLE hMutex);

該函數(shù)將對象的遞歸計數(shù)器遞減1。

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

就等待線程的調(diào)度而言，互斥對象與關鍵代碼段之間有著相同的特性。但是它們在其他屬性方面卻各不相同。表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);