由于大小和性能方面的原因，

多个线程之间需要协调运行。例如，如果第二个线程需要等待第一个线程完成到某一步时才能运行，那么该线程应该暂时挂起以减少对

关键节 (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);