临界区，互斥量，信号量，事件的区别(线程同步) 收藏

四种进程或线程同步互斥的控制方法

1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。

2、互斥量:为协调共同对一个共享资源的单独访问而设计的。

3、信号量:为控制一个具有有限数量用户资源而设计。

4、事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

 

临界区（CriticalSection）

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

临界区包含两个操作原语：

EnterCriticalSection（） 进入临界区

LeaveCriticalSection（） 离开临界区

EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本进程内的线程，而不可用来同步多个进程中的线程。

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

互斥量（Mutex）

互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程 所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。

 

互斥量包含的几个操作原语：

CreateMutex（）创建一个互斥量

OpenMutex（）打开一个互斥量

ReleaseMutex（）释放互斥量

WaitForMultipleObjects（） 等待互斥量对象

 

同样MFC为互斥量提供有一个CMutex类。使用CMutex类实现互斥量操作非常简单，但是要特别注意对CMutex的构造函数的调用

CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTRlpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL)

不用的参数不能乱填，乱填会出现一些意想不到的运行结果。

 

信号量（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（） 等待信号量

事件（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。

 

总结：

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

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

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

 

1、  Event
用事件（Event）来同步线程是最具弹性的了。一个事件有两种状态：激发状态和未激发状态。也称有信号状态和无信号状态。事件又分两种类型：手动重置事件和自动重置事件。手动重置事件被设置为激发状态后，会唤醒所有等待的线程，而且一直保持为激发状态，直到程序重新把它设置为未激发状态。自动重置事件被设置为激发状态后，会唤醒“一个”等待中的线程，然后自动恢复为未激发状态。所以用自动重置事件来同步两个线程比较理想。MFC中对应的类为CEvent.。CEvent的构造函数默认创建一个自动重置的事件，而且处于未激发状态。共有三个函数来改变事件的状态:SetEvent,ResetEvent和PulseEvent。用事件来同步线程是一种比较理想的做法，但在实际的使用过程中要注意的是，对自动重置事件调用SetEvent和PulseEvent有可能会引起死锁，必须小心。
2、  Critical Section
使用临界区域的第一个忠告就是不要长时间锁住一份资源。这里的长时间是相对的，视不同程序而定。对一些控制软件来说，可能是数毫秒，但是对另外一些程序来说，可以长达数分钟。但进入临界区后必须尽快地离开，释放资源。如果不释放的话，会如何？答案是不会怎样。如果是主线程（GUI线程）要进入一个没有被释放的临界区，呵呵，程序就会挂了！临界区域的一个缺点就是：Critical Section不是一个核心对象，无法获知进入临界区的线程是生是死，如果进入临界区的线程挂了，没有释放临界资源，系统无法获知，而且没有办法释放该临界资源。这个缺点在互斥器(Mutex)中得到了弥补。Critical Section在MFC中的相应实现类是CcriticalSection。CcriticalSection：：Lock()进入临界区，CcriticalSection：：UnLock()离开临界区。
3、  Mutex
互斥器的功能和临界区域很相似。区别是：Mutex所花费的时间比Critical Section多的多，但是Mutex是核心对象(Event、Semaphore也是)，可以跨进程使用，而且等待一个被锁住的Mutex可以设定TIMEOUT，不会像Critical Section那样无法得知临界区域的情况，而一直死等。MFC中的对应类为CMutex。Win32函数有：创建互斥体CreateMutex() ，打开互斥体OpenMutex()，释放互斥体ReleaseMutex()。Mutex的拥有权并非属于那个产生它的线程，而是最后那个对此Mutex进行等待操作（WaitForSingleObject等等）并且尚未进行ReleaseMutex()操作的线程。线程拥有Mutex就好像进入Critical Section一样，一次只能有一个线程拥有该Mutex。如果一个拥有Mutex的线程在返回之前没有调用ReleaseMutex()，那么这个Mutex就被舍弃了，但是当其他线程等待(WaitForSingleObject等)这个Mutex时，仍能返回，并得到一个WAIT_ABANDONED_0返回值。能够知道一个Mutex被舍弃是Mutex特有的。
4、  Semaphore
信号量是最具历史的同步机制。信号量是解决producer/consumer问题的关键要素。对应的MFC类是Csemaphore。Win32函数CreateSemaphore（）用来产生信号量。ReleaseSemaphore（）用来解除锁定。Semaphore的现值代表的意义是目前可用的资源数，如果Semaphore的现值为1，表示还有一个锁定动作可以成功。如果现值为5，就表示还有五个锁定动作可以成功。当调用Wait…等函数要求锁定，如果Semaphore现值不为0，Wait…马上返回，资源数减1。当调用ReleaseSemaphore（）资源数加1，当时不会超过初始设定的资源总数。

 

4 种进程或线程同步互斥的控制方法

很想整理一下自己对进程线程同步互斥的理解。正巧周六一个刚刚回到学校的同学请客吃饭。在吃饭的过程中，有两个同学，为了一个问题争论的面红耳赤。一个认为.Net下的进程线程控制模型更加合理。一个认为Java下的线程池策略比.Net的好。大家的话题一下转到了进程线程同步互斥的控制问题上。回到家，想了想就写了这个东东。
??　　 现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。
??　　 这4种方法具体定义如下 在《操作系统教程》ISBN 7-5053-6193-7 一书中可以找到更加详细的解释
??　　　 1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
??　　　 2互斥量:为协调共同对一个共享资源的单独访问而设计的。
??　　　 3信号量:为控制一个具有有限数量用户资源而设计。
??　　　 4事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。
??
??　　 临界区（CriticalSection）
??　　 保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。
?? 临界区包含两个操作原语：
??　　 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();
?? }
??
??　　 在测试程序中，LockUnLock两个按钮分别实现，在有临界区保护共享资源的执行状态，和没有临界区保护共享资源的执行状态。
??　　 程序运行结果
??　　
??　　 互斥量（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;
?? }
??　　 同样在测试程序中，LockUnLock两个按钮分别实现，在有互斥量保护共享资源的执行状态，和没有互斥量保护共享资源的执行状态。
??　　 程序运行结果
??　　
??
??　　 信号量（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． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数器。
??　　 疑问：
??　　 在 Linux上，有两类信号量。第一类是由 semget/semop/semctlAPI 定义的信号量的 SVR4（System V Release 4）版本。第二类是由sem_init/sem_wait/sem_post/interfaces 定义的 POSIX 接口。 它们具有相同的功能，但接口不同。 在2.4.x内核中，信号量数据结构定义为(include/asm/semaphore.h)。
?? 但是在Linux中没有对互斥量的具体提法，只是看到说互斥量是信号量的一种特殊情况，当信号量的最大资源数=1同时可以访问共享资源的线程数=1 就是互斥量了。临界区的定义也比较模糊。没有找到用事件处理线程/进程同步互斥的操作的相关资料。在Linux下用GCC/G++编译标准C++代码，信号量的操作几乎和Windows下VC7的编程一样，不用改多少就顺利移植了，可是互斥量，事件，临界区的Linux移植没有成功。
??
??　　 本文所有事例程序在WindowsXpSp2 + VC7 下编译通过

临界区是一个进程里的所有线程同步的最好办法，他不是系统级的，只是进程级的，也就是说他可能利用进程内的一些标志来保证该进程内的线程同步，据Richter说是一个记数循环；临界区只能在同一进程内使用；临界区只能无限期等待，不过2k增加了TryEnterCriticalSection函数实现0时间等待。
互斥则是保证多进程间的线程同步，他是利用系统内核对象来保证同步的。由于系统内核对象可以是有名字的，因此多个进程间可以利用这个有名字的内核对象保证系统资源的线程安全性。互斥量是Win32 内核对象，由操作系统负责管理；互斥量可以使用WaitForSingleObject实现无限等待，0时间等待和任意时间等待。
1. 临界区
临界区是一种最直接的线程同步方式。所谓临界区，就是一次只能由一个线程来执行的一段代码。如果把初始化数组的代码放在临界区内，另一个线程在第一个线程处理完之前是不会被执行的。在使用临界区之前，必须使用InitializeCriticalSection()过程来初始化它。
在第一个线程调用了EnterCriticalSection()之后，所有别的线程就不能再进入代码块。下一个线程要等第一个线程调用LeaveCriticalSection()后才能被唤醒。
2. 互斥
互斥非常类似于临界区，除了两个关键的区别：首先，互斥可用于跨进程的线程同步。其次，互斥能被赋予一个字符串名字，并且通过引用此名字创建现有互斥对象的附加句柄。
提示：临界区与事件对象(比如互斥对象)的最大的区别是在性能上。临界区在没有线程冲突时，要用10 ~ 15个时间片，而事件对象由于涉及到系统内核要用400~600个时间片。
当一个互斥对象不再被一个线程所拥有,它就处于发信号状态。此时首先调用WaitForSingleObject()函数的线程就成为该互斥对象的拥有者，此互斥对象设为不发信号状态。当线程调用ReleaseMutex()函数并传递一个互斥对象的句柄作为参数时，这种拥有关系就被解除，互斥对象重新进入发信号状态。
可以调用函数CreateMutex()来创建一个互斥量。当使用完互斥对象时，应当调用CloseHandle()来关闭它。
3. 信号量
另一种使线程同步的技术是使用信号量对象。它是在互斥的基础上建立的，但信号量增加了资源计数的功能，预定数目的线程允许同时进入要同步的代码。可以用CreateSemaphore()来创建一个信号量对象，
因为只允许一个线程进入要同步的代码，所以信号量的最大计数值(lMaximumCount)要设为1。ReleaseSemaphore()函数将使信号量对象的计数加1；
记住，最后一定要调用CloseHandle()函数来释放由CreateSemaphore()创建的信号量对象的句柄。
★★★WaitForSingleObject函数的返值：
WAIT_ABANDONED指定的对象是互斥对象，并且拥有这个互斥对象的线程在没有释放此对象之前就已终止。此时就称互斥对象被抛弃。这种情况下，这个互斥对象归当前线程所有，并把它设为非发信号状态；
WAIT_OBJECT_0 指定的对象处于发信号状态；
WAIT_TIMEOUT等待的时间已过，对象仍然是非发信号状态；

 

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/binghuazh/archive/2009/09/24/4589030.aspx