进程/线程同步——Critical Section,Mutex,Semaphore,Event区别

╰+哭是因爲堅強的太久メ 2022-08-05 08:00 122阅读 0赞

转自：http://blog.163.com/around-wind/blog/static/271230752009084037565/

临界区（Critical Section）

保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进 入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共 享资源的目的。

临界区包含两个操作原语： EnterCriticalSection（） 进入临界区 LeaveCriticalSection（） 离开临界区

EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的 LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。在使用临界区时，一般不允许其运行时间过长， 只要进入临界区的线程还没有离开，其他所有试图进入此临界区的线程都会被挂起而进入到等待状态，并会在一定程度上影响。程序的运行性能。尤其需要注意的是 不要将等待用户输入或是其他一些外界干预的操作包含到临界区。如果进入了临界区却一直没有释放，同样也会引起其他线程的长时间等待。换句话说，在执行了 EnterCriticalSection（）语句进入临界区后无论发生什么，必须确保与之匹配的LeaveCriticalSection（）都能够被 执行到。可以通过添加结构化异常处理代码来确保LeaveCriticalSection（）语句的执行。虽然临界区同步速度很快，但却只能用来同步本进 程内的线程，而不可用来同步多个进程中的线程。

MFC提供了很多功能完备的类，我用MFC实现了临界区。MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是非常 简单的。只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。Lock（）后代码用 到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。

互斥量（Mutex）

互斥（Mutex）是一种用途非常广泛的内核对象。能够保证多个线程对同一共享资源的互斥访问。同临界区有些类似，只有拥有互斥对象的线程才具有访问资源 的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交 出，以便其他线程在获得后得以访问资源。与其他几种内核对象不同，互斥对象在操作系统中拥有特殊代码，并由操作系统来管理，操作系统甚至还允许其进行一些 其他内核对象所不能进行的非常规操作。 互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访 问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应 用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。

以互斥内核对象来保持线程同步可能用到的函数主要有CreateMutex（）、OpenMutex（）、ReleaseMutex（）、 WaitForSingleObject（）和WaitForMultipleObjects（）等。在使用互斥对象前，首先要通过 CreateMutex（）或OpenMutex（）创建或打开一个互斥对象。CreateMutex（）函数原型为：

HANDLE CreateMutex(

LPSECURITY\_ATTRIBUTES lpMutexAttributes, // 安全属性指针

BOOL bInitialOwner, // 初始拥有者

LPCTSTR lpName // 互斥对象名

);

参数bInitialOwner主要用来控制互斥对象的初始状态。一般多将其设置为 FALSE，以表明互斥对象在创建时并没有为任何线程所占有。如果在创建互斥对象时指定了对象名，那么可以在本进程其他地方或是在其他进程通过 OpenMutex（）函数得到此互斥对象的句柄。OpenMutex（）函数原型为：

HANDLE OpenMutex(

DWORD dwDesiredAccess, // 访问标志

BOOL bInheritHandle, // 继承标志

LPCTSTR lpName // 互斥对象名

);

当目前对资源具有访问权的线程不再需要访问此资源而要离开时，必须通过ReleaseMutex（）函数来释放其拥有的互斥对象，其函数原型为：

BOOL ReleaseMutex(HANDLE hMutex);

其唯一的参数hMutex为待释放的互斥对象句柄。至于 WaitForSingleObject（）和WaitForMultipleObjects（）等待函数在互斥对象保持线程同步中所起的作用与在其他内 核对象中的作用是基本一致的，也是等待互斥内核对象的通知。但是这里需要特别指出的是：在互斥对象通知引起调用等待函数返回时，等待函数的返回值不再是通 常的WAIT\_OBJECT\_0（对于WaitForSingleObject（）函数）或是在WAIT\_OBJECT\_0到 WAIT\_OBJECT\_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数），而是将返回一个 WAIT\_ABANDONED\_0（对于WaitForSingleObject（）函数）或是在WAIT\_ABANDONED\_0到 WAIT\_ABANDONED\_0+nCount-1之间的一个值（对于WaitForMultipleObjects（）函数）。以此来表明线程正在等 待的互斥对象由另外一个线程所拥有，而此线程却在使用完共享资源前就已经终止。除此之外，使用互斥对象的方法在等待线程的可调度性上同使用其他几种内核对 象的方法也有所不同，其他内核对象在没有得到通知时，受调用等待函数的作用，线程将会挂起，同时失去可调度性，而使用互斥的方法却可以在等待的同时仍具有 可调度性，这也正是互斥对象所能完成的非常规操作之一。

在编写程序时，互斥对象多用在对那些为多个线程所访问的内存块的保护上，可以确保任何线程在处理此内存块时都对其拥有可靠的独占访问权。

互斥对象在MFC中通过CMutex类进行表述。使用CMutex类的方法非常简单，在构造CMutex类对象的同时可以指明待查询的互斥对象的名字，在 构造函数返回后即可访问此互斥变量。CMutex类也是只含有构造函数这唯一的成员函数，当完成对互斥对象保护资源的访问后，可通过调用从父类 CSyncObject继承的UnLock（）函数完成对互斥对象的释放。CMutex类构造函数原型为：

CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY\_ATTRIBUTES lpsaAttribute = NULL );

该类的适用范围和实现原理与API方式创建的互斥内核对象是完全类似的，但要简洁的多。

Mutex和Critical Section都是主要用于限制多线程（Multithread）对全局或共享的变量、对象或内存空间的访问。下面是其主要的异同点（不同的地方用绿色表示）。

<table style="color:rgb(51,51,51); font-size:14px; line-height:26px; font-family:Verdana,Helvetica,Arial; border-collapse:collapse; background-color:rgb(247,247,247)"> 
 <tbody> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> Mutex </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> Critical Section </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 性能和速度 </td> 
 <td style="color:red; font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> 慢。 Mutex 是内核对象，相关函数的执行 （WaitForSingleObject， ReleaseMutex）需要用户模式（User Mode）到内核模式（Kernel Mode）的转换，在x86处理器上这种转化一般要发费600个左右的 CPU指令周期。 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> 快。 Critical Section本身不是内核对象，相关函数（EnterCriticalSection，LeaveCriticalSection）的调用一般都在用户模式内执行，在x86处理器上一般只需要发费9个左右的 CPU指令周期。只有当想要获得的锁正好被别的线程拥有时才会退化成和Mutex一样，即转换到内核模式，发费600个左右的 CPU指令周期。 </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 能否跨越进程（Process）边界 </td> 
 <td style="color:red; font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> 可以 </td> 
 <td style="color:red; font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> 不可 </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 定义写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> HANDLE hmtx; </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> CRITICAL_SECTION cs; </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 初始化写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> hmtx= CreateMutex (NULL, FALSE, NULL); </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> InitializeCriticalSection(&amp;cs); </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 结束清除写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> CloseHandle(hmtx); </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> DeleteCriticalSection(&amp;cs); </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 无限期等待的写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> WaitForSingleObject (hmtx, INFINITE); </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> EnterCriticalSection(&amp;cs); </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 0等待（状态检测）的写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> WaitForSingleObject (hmtx, 0); </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> TryEnterCriticalSection(&amp;cs); </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 任意时间等待的写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> WaitForSingleObject (hmtx, dwMilliseconds); </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> 不支持 </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 锁释放的写法 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> ReleaseMutex(hmtx); </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> LeaveCriticalSection(&amp;cs); </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 能否被一道用于等待其他内核对象 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> 可以（使用WaitForMultipleObjects，WaitForMultipleObjectsEx，MsgWaitForMultipleObjects，&nbsp;MsgWaitForMultipleObjectsEx等等） </td> 
 <td style="color:red; font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> 不可 </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 当拥有锁的线程死亡时 </td> 
 <td style="color:red; font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> Mutex变成abandoned状态，其他的等待线程可以获得锁。 </td> 
 <td style="color:red; font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> Critical Section的状态不可知（undefined），以后的动作就不能保证了。 </td> 
 </tr> 
 <tr> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:154.25pt; background-color:transparent"> 自己会不会锁住自己 </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:192.45pt; background-color:transparent"> 不会（对已获得的Mutex,重复调用WaitForSingleObject不会锁住自己。但最后你别忘了要调用同样次数的ReleaseMutex） </td> 
 <td style="color:rgb(69,69,69); font-family:Verdana,Helvetica,Arial; word-break:break-all; line-height:18px; padding:0mm 5.4pt; width:173.4pt; background-color:transparent"> 不会（对已获得的Critical Section,重复调用EnterCriticalSection不会锁住自己。但最后你别忘了要调用同样次数的LeaveCriticalSection） </td> 
 </tr> 
 </tbody> 
</table>

信号量（Semaphores）

信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最大 数目。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore（）创建信号量时即 要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会 减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能 在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用资 源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。 信号量是通过计数来对线程访问资源进行控制的，而实际上信号量确实也被称作Dijkstra计数器。

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（）和WaitForMultipleObjects（）等函数。其 中，CreateSemaphore（）用来创建一个信号量内核对象，其函数原型为：

HANDLE CreateSemaphore(

LPSECURITY\_ATTRIBUTES lpSemaphoreAttributes, // 安全属性指针

LONG lInitialCount, // 初始计数

LONG lMaximumCount, // 最大计数

LPCTSTR lpName // 对象名指针

);

参数lMaximumCount是一个有符号32位值，定义了允许的最大资源计数，最大 取值不能超过4294967295。lpName参数可以为创建的信号量定义一个名字，由于其创建的是一个内核对象，因此在其他进程中可以通过该名字而得 到此信号量。OpenSemaphore（）函数即可用来根据信号量名打开在其他进程中创建的信号量，函数原型如下：

HANDLE OpenSemaphore(

DWORD dwDesiredAccess, // 访问标志

BOOL bInheritHandle, // 继承标志

LPCTSTR lpName // 信号量名

);

在线程离开对共享资源的处理时，必须通过ReleaseSemaphore（）来增加当 前可用资源计数。否则将会出现当前正在处理共享资源的实际线程数并没有达到要限制的数值，而其他线程却因为当前可用资源计数为0而仍无法进入的情况。 ReleaseSemaphore（）的函数原型为：

BOOL ReleaseSemaphore(

HANDLE hSemaphore, // 信号量句柄

LONG lReleaseCount, // 计数递增数量

LPLONG lpPreviousCount // 先前计数

);

该函数将lReleaseCount中的值添加给信号量的当前资源计数，一般将 lReleaseCount设置为1，如果需要也可以设置其他的值。WaitForSingleObject（）和 WaitForMultipleObjects（）主要用在试图进入共享资源的线程函数入口处，主要用来判断信号量的当前可用资源计数是否允许本线程的进 入。只有在当前可用资源计数值大于0时，被监视的信号量内核对象才会得到通知。

信号量的使用特点使其更适用于对Socket（套接字）程序中线程的同步。例如，网络上 的HTTP服务器要对同一时间内访问同一页面的用户数加以限制，这时可以为没一个用户对服务器的页面请求设置一个线程，而页面则是待保护的共享资源，通过 使用信号量对线程的同步作用可以确保在任一时刻无论有多少用户对某一页面进行访问，只有不大于设定的最大用户数目的线程能够进行访问，而其他的访问企图则 被挂起，只有在有用户退出对此页面的访问后才有可能进入。

在MFC中，通过CSemaphore类对信号量作了表述。该类只具有一个构造函数，可以构造一个信号量对象，并对初始资源计数、最大资源计数、对象名和安全属性等进行初始化，其原型如下：

CSemaphore( LONG lInitialCount = 1, LONG lMaxCount = 1, LPCTSTR pstrName = NULL, LPSECURITY\_ATTRIBUTES lpsaAttributes = NULL );

在构造了CSemaphore类对象后，任何一个访问受保护共享资源的线程都必须通过 CSemaphore从父类CSyncObject类继承得到的Lock（）和UnLock（）成员函数来访问或释放CSemaphore对象。与前面介 绍的几种通过MFC类保持线程同步的方法类似，通过CSemaphore类也可以将前面的线程同步代码进行改写，这两种使用信号量的线程同步方法无论是在 实现原理上还是从实现结果上都是完全一致的。

事件（Event）

事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。

信号量包含的几个操作原语：

CreateEvent（） 创建一个信号量

OpenEvent（） 打开一个事件

SetEvent（） 回置事件

WaitForSingleObject（） 等待一个事件

WaitForMultipleObjects（）　等待多个事件

使用临界区只能同步同一进程中的线程，而使用事件内核对象则可以对进程外的线程进行同步，其前提是得到对此事件对象的访问权。可以通过OpenEvent（）函数获取得到，其函数原型为：

HANDLE OpenEvent(

DWORD dwDesiredAccess, // 访问标志

BOOL bInheritHandle, // 继承标志

LPCTSTR lpName // 指向事件对象名的指针

);

如果事件对象已创建（在创建事件时需要指定事件名），函数将返回指定事件的句柄。对于那 些在创建事件时没有指定事件名的事件内核对象，可以通过使用内核对象的继承性或是调用DuplicateHandle（）函数来调用 CreateEvent（）以获得对指定事件对象的访问权。在获取到访问权后所进行的同步操作与在同一个进程中所进行的线程同步操作是一样的。

如果需要在一个线程中等待多个事件，则用 WaitForMultipleObjects（）来等待。WaitForMultipleObjects（）与 WaitForSingleObject（）类似，同时监视位于句柄数组中的所有句柄。这些被监视对象的句柄享有平等的优先权，任何一个句柄都不可能比其 他句柄具有更高的优先权。WaitForMultipleObjects（）的函数原型为：

DWORD WaitForMultipleObjects(

DWORD nCount, // 等待句柄数

CONST HANDLE \*lpHandles, // 句柄数组首地址

BOOL fWaitAll, // 等待标志

DWORD dwMilliseconds // 等待时间间隔

);

参数nCount指定了要等待的内核对象的数目，存放这些内核对象的数组由 lpHandles来指向。fWaitAll对指定的这nCount个内核对象的两种等待方式进行了指定，为TRUE时当所有对象都被通知时函数才会返 回，为FALSE则只要其中任何一个得到通知就可以返回。dwMilliseconds在这里的作用与在WaitForSingleObject（）中的 作用是完全一致的。如果等待超时，函数将返回WAIT\_TIMEOUT。如果返回WAIT\_OBJECT\_0到 WAIT\_OBJECT\_0+nCount-1中的某个值，则说明所有指定对象的状态均为已通知状态（当fWaitAll为TRUE时）或是用以减去 WAIT\_OBJECT\_0而得到发生通知的对象的索引（当fWaitAll为FALSE时）。如果返回值在WAIT\_ABANDONED\_0与 WAIT\_ABANDONED\_0+nCount-1之间，则表示所有指定对象的状态均为已通知，且其中至少有一个对象是被丢弃的互斥对象（当 fWaitAll为TRUE时），或是用以减去WAIT\_OBJECT\_0表示一个等待正常结束的互斥对象的索引（当fWaitAll为FALSE时）。

MFC为事件相关处理也提供了一个CEvent类，共包含有除构造函数外的4个成员函数 PulseEvent（）、ResetEvent（）、SetEvent（）和UnLock（）。在功能上分别相当与Win32 API的PulseEvent（）、ResetEvent（）、SetEvent（）和CloseHandle（）等函数。而构造函数则履行了原 CreateEvent（）函数创建事件对象的职责，其函数原型为：

CEvent(BOOL bInitiallyOwn = FALSE, BOOL bManualReset = FALSE, LPCTSTR lpszName = NULL, LPSECURITY\_ATTRIBUTES lpsaAttribute = NULL );

按照此缺省设置将创建一个自动复位、初始状态为复位状态的没有名字的事件对象。封装后的CEvent类使用起来更加方便，

事件可以实现不同进程中的线程同步操作，并且可以方便的实现多个线程的优先比较等待操作，例如写多个WaitForSingleObject来代替WaitForMultipleObjects从而使编程更加灵活。

总结：

1． 互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使 用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。

2． 互斥量（Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但 对于进程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和 线程退出。

3． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根 据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数 器。