临界区，互斥量，信号量，事件的区别

转自：http://blog.csdn.net/wuyuan2011woaini/article/details/7564842

临界区(Critical section)与互斥体(Mutex)的区别

1、临界区只能用于对象在同一进程里线程间的互斥访问；互斥体可以用于对象进程间或线程间的互斥访问。

2、临界区是非内核对象，只在用户态进行锁操作，速度快；互斥体是内核对象，在核心态进行锁操作，速度慢。

3、临界区和互斥体在Windows平台都下可用；Linux下只有互斥体可用。

 

临界区，互斥量，信号量，事件的区别

四种进程或线程同步互斥的控制方法
1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。 
2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 
3、信号量:为控制一个具有有限数量用户资源而设计。 
4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

 临界区（Critical Section）

保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么 在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操 作共享资源的目的。 
临界区包含两个操作原语： 
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, LPCTSTR lpszName = 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． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数器。

关于更详细的一篇介绍，请看这里：

http://blog.csdn.net/wuyuan2011woaini/article/details/7564825

事件对象： 
      事件对象也属于内核对象，包含一个计数器，一个用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件是处于已通知还是未通知状态的布尔值。

两种事件对象：
1.人工重置的事件。   当一个人工重置的事件得到通知时，等待该事件的所有线程均为可调度线程。
2.自动重置的事件。   当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调动线程。

关键代码段：
关键代码段（临界区）工作在用户方式下。

关键代码段（临界区）是指一小代码段，在代码能够执行前，它必须独占对某些资源的访问权。

线程死锁：
线程1拥有了临界区对象A，等待临界区对象B的拥有权，线程2拥有了临界区对象B，等待临界区对象A的拥有权，就造成了死锁。


互斥对象、事件对象和关键代码段的比较
互斥对象和事件对象都属于内核对象，利用内核对象进行线程同步，速度较慢，但利用互斥对象和事件对象这样的内核对象，可以在多个进程中的各个线程间进行同步。

关键代码段是工作在用户方式下，同步速度较快，但在使用关键代码段时，很容易进入死锁状态，因为在等待进入关键代码段时无法设定超时值。

VC下线程同步的三种方法(互斥、事件、临界区)

首选使用临界区对象,主要原因是使用简单。  
EnterCriticalSection（）函数等候指定的危险区段对象的所有权。当调用的线程被允许所有权时，函数返回。  
EnterCriticalSection （），一个单独进程的线程可以使用一个危险区段对象作为相互-排除同步。 进程负责分配被一个危险区段对象使用的内存, 它藉由声明一个CRITICAL_SECTION类型 的变量实现。在使用一个危险区段之前，进程的一些线程必须调用 InitializeCriticalSection 函数设定对象的初值. 
为了要使互斥的访问被共享的资源,每个线程调用EnterCriticalSection 或者 TryEnterCriticalSection 功能，在执行访问被保护资源的任何代码段之前，请求危险区段的所有权。  

01#include <windows.h>

02#include <iostream>

03using namespace std;

04DWORD WINAPI Fun1Proc(LPVOID lpParameter);

05DWORD WINAPI Fun2Proc(LPVOID lpParameter);

06int tickets=100;

07CRITICAL_SECTION g_csA;

08CRITICAL_SECTION g_csB;

09void main()

10{

11 HANDLE hThread1;

12 HANDLE hThread2;

13 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

14 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

15 CloseHandle(hThread1);

16 CloseHandle(hThread2);

17 InitializeCriticalSection(&g_csA);

18 InitializeCriticalSection(&g_csB);

19 Sleep(40000);

20 DeleteCriticalSection(&g_csA);

21 DeleteCriticalSection(&g_csB);

22}

23DWORD WINAPI Fun1Proc(LPVOID lpParameter)

24{

25 while (TRUE)

26 {

27  EnterCriticalSection(&g_csA);

28  Sleep(1);

29  //EnterCriticalSection(&g_csB);//临界区的同步和互锁

30  if (tickets>0)

31  {

32   Sleep(1);

33   cout<<"Thread1 sell ticket :"<<tickets--<<endl;

34   //LeaveCriticalSection(&g_csB);

35   LeaveCriticalSection(&g_csA);

36  }

37  else

38  {

39   //LeaveCriticalSection(&g_csB);

40   LeaveCriticalSection(&g_csA);

41   break;

42  }

43 }

44 return 0;

45}

46DWORD WINAPI Fun2Proc(LPVOID lpParameter)

47{

48 while (TRUE)

49 {

50  EnterCriticalSection(&g_csB);

51  Sleep(1);

52  EnterCriticalSection(&g_csA);

53  if (tickets>0)

54  {

55   Sleep(1);

56   cout<<"Thread2 sell ticket :"<<tickets--<<endl;

57   LeaveCriticalSection(&g_csA);

58   LeaveCriticalSection(&g_csB);

59  }

60  else

61  {

62   LeaveCriticalSection(&g_csA);

63   LeaveCriticalSection(&g_csB);

64   break;

65  }

66 }

67 return 0;

68}

  

-------------------------------------------------------------------------------- 

二、使用互斥对象 
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);  
如果时间是有信号状态返回WAIT_OBJECT_0，如果时间超过dwMilliseconds值但时间事件还是无信号状态则返回WAIT_TIMEOUT 
WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds就返回，但如果参数dwMilliseconds为INFINITE时函数将直到相应时间事件变成有信号状态才返回，否则就一直等待下去，直到WaitForSingleObject有返回直才执行后面的代码。 

01#include <windows.h>

02#include <iostream>

03using namespace std; 

04DWORD WINAPI Fun1Proc(LPVOID lpParameter);

05DWORD WINAPI Fun2Proc(LPVOID lpParameter);

06int index =0;

07int tickets=100;

08HANDLE hMutex;

09void main()

10{

11 HANDLE hThread1;

12 HANDLE hThread2;

13 //创建线程

14 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

15 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

16 CloseHandle(hThread1);

17 CloseHandle(hThread2);

18 //**************************************************************

19 //保证应用程序只有一个实例运行,创建一个命名的互斥对象.

20 hMutex=CreateMutex(NULL,TRUE,LPCTSTR("tickets"));

21 //创建时主线程拥有该互斥对象,互斥对象的线程ID为主线程的ID,同时将该互斥对象内部计数器置为1

22 if (hMutex)

23 {

24  if (ERROR_ALREADY_EXISTS==GetLastError())

25  {

26   cout<<"only one instance can run!"<<endl;

27   //Sleep(40000);

28   return;

29  }

30 }

31 //**************************************************************

32 WaitForSingleObject(hMutex,INFINITE);

33 //使用该函数请求互斥对象时,虽说该对象处于无信号状态,但因为请求的线程ID和该互斥对象所有者的线程ID是相同的.所以仍然可以请求到这个互斥对象,于是该互斥对象内部计数器加1,内部计数器的值为2. 意思是有两个等待动作

34 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象内部计数器的值递减1,操作系统不会将这个互斥对象变为已通知状态.

35 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象内部计数器的值为0,同时将该对象设置为已通知状态.

36 //对于互斥对象来说,谁拥有谁释放

37 Sleep(40000);

38}

39DWORD WINAPI Fun1Proc(LPVOID lpParameter)

40{

41 while (TRUE)

42 {

43  WaitForSingleObject(hMutex,INFINITE);//等待互斥对象有信号

44  if (tickets>0)

45  {

46   Sleep(1);

47   cout<<"thread1 sell ticket :"<<tickets--<<endl;

48  }

49  else

50   break;

51  ReleaseMutex(hMutex);//设置该互斥对象的线程ID为0,并且将该对象设置为有信号状态

52 }

53 return 0;

54}

55DWORD WINAPI Fun2Proc(LPVOID lpParameter)

56{

57 while (TRUE)

58 {

59  WaitForSingleObject(hMutex,INFINITE);

60  if (tickets>0)

61  {

62   Sleep(1);

63   cout<<"thread2 sell ticket :"<<tickets--<<endl;

64  }

65  else

66   break;

67  ReleaseMutex(hMutex);

68 }

69 return 0;

70}

  

-------------------------------------------------------------------------------- 

三、使用事件对象 

1HANDLE     CreateEvent(   

2        LPSECURITY_ATTRIBUTES     lpEventAttributes,           //     SD   

3        BOOL    bManualReset,                                                 //     reset     type   

4        BOOL    bInitialState,                                                     //     initial     state   

5        LPCTSTR    lpName                                                      //     object     name   

6    );

    
    该函数创建一个Event同步对象,并返回该对象的Handle    
     
    lpEventAttributes     一般为NULL    
    bManualReset               创建的Event是自动复位还是人工复位     ,如果true,人工复位,    
    一旦该Event被设置为有信号,则它一直会等到ResetEvent()API被调用时才会恢复    
    为无信号.     如果为false,Event被设置为有信号,则当有一个wait到它的Thread时,    
    该Event就会自动复位,变成无信号.    
    bInitialState             初始状态,true,有信号,false无信号    
    lpName                           Event对象名    
     
    一个Event被创建以后,可以用OpenEvent()API来获得它的Handle,用CloseHandle()    
    来关闭它,用SetEvent()或PulseEvent()来设置它使其有信号,用ResetEvent()    
    来使其无信号,用WaitForSingleObject()或WaitForMultipleObjects()来等待    
    其变为有信号.    
     
    PulseEvent()是一个比较有意思的使用方法,正如这个API的名字,它使一个Event    
    对象的状态发生一次脉冲变化,从无信号变成有信号再变成无信号,而整个操作是原子的.    
    对自动复位的Event对象,它仅释放第一个等到该事件的thread（如果有),而对于    
    人工复位的Event对象,它释放所有等待的thread.   

显示代码

打印

01#include <windows.h>

02#include <iostream>

03using namespace std;

04DWORD WINAPI Fun1Proc(LPVOID lpParameter);

05DWORD WINAPI Fun2Proc(LPVOID lpParameter);

06int tickets=100;

07HANDLE g_hEvent;

08void main()

09{

10 HANDLE hThread1;

11 HANDLE hThread2;

12 //**************************************************

13 //创建一个命名的自动重置事件内核对象

14 g_hEvent=CreateEvent(NULL,FALSE,FALSE,LPCTSTR("tickets"));

15 if (g_hEvent)

16 {

17  if (ERROR_ALREADY_EXISTS==GetLastError())

18  {

19   cout<<"only one instance can run!"<<endl;

20   return;

21  }

22 }

23 //**************************************************

24 SetEvent(g_hEvent);

25 //创建线程

26 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

27 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

28 Sleep(40000);

29 //关闭事件对象句柄

30 CloseHandle(g_hEvent);

31}

32DWORD WINAPI Fun1Proc(LPVOID lpParameter)

33{

34 while (TRUE)

35 {

36  WaitForSingleObject(g_hEvent,INFINITE);

37  //ResetEvent(g_hEvent);

38  if (tickets>0)

39  {

40   Sleep(1);

41   cout<<"thread1 sell ticket :"<<tickets--<<endl;

42   SetEvent(g_hEvent);

43  }

44  else

45  {

46   SetEvent(g_hEvent);

47   break;

48  }

49 }

50 return 0;

51}

52DWORD WINAPI Fun2Proc(LPVOID lpParameter)

53{

54 while (TRUE)

55 {

56  WaitForSingleObject(g_hEvent,INFINITE);

57  //ResetEvent(g_hEvent);

58  if (tickets>0)

59  {

60   cout<<"Thread2 sell ticket :"<<tickets--<<endl;

61   SetEvent(g_hEvent);

62  }

63  else

64  {

65   SetEvent(g_hEvent);

66   break;

67  }

68 }

69 return 0;