【转】互斥对象锁和临界区锁性能比较

原作者：chexlong 原文地址：http://blog.csdn.net/chexlong/article/details/7060425

在Win32平台上进行多线程编程，常会用到锁。下边用C++实现了互斥对象（Mutex）锁和临界区（CRITICAL_SECTION）锁，以加深理解和今后方便使用。代码已在VS2005环境下编译测试通过。

Lock.h

[cpp] view plaincopy

1. #ifndef _Lock_H
2. #define _Lock_H
3. #include <windows.h>
4. //锁接口类
5. class ILock
6. {
7. public:
8. virtual ~ILock() {}
9. virtual void Lock() const = 0;
10. virtual void Unlock() const = 0;
11. };
12. //互斥对象锁类
13. class Mutex : public ILock
14. {
15. public:
16. Mutex();
17. ~Mutex();
18. virtual void Lock() const;
19. virtual void Unlock() const;
20. private:
21. HANDLE m_mutex;
22. };
23. //临界区锁类
24. class CriSection : public ILock
25. {
26. public:
27. CriSection();
28. ~CriSection();
29. virtual void Lock() const;
30. virtual void Unlock() const;
31. private:
32. CRITICAL_SECTION m_critclSection;
33. };
34. //锁
35. class CMyLock
36. {
37. public:
38. CMyLock(const ILock&);
39. ~CMyLock();
40. private:
41. const ILock& m_lock;
42. };
43. #endif

Lock.cpp

[cpp] view plaincopy

1. #include "Lock.h"
2. //---------------------------------------------------------------------------
3. //创建一个匿名互斥对象
4. Mutex::Mutex()
5. {
6. m_mutex = ::CreateMutex(NULL, FALSE, NULL);
7. }
8. //销毁互斥对象，释放资源
9. Mutex::~Mutex()
10. {
11. ::CloseHandle(m_mutex);
12. }
13. //确保拥有互斥对象的线程对被保护资源的独自访问
14. void Mutex::Lock() const
15. {
16. DWORD d = WaitForSingleObject(m_mutex, INFINITE);
17. }
18. //释放当前线程拥有的互斥对象，以使其它线程可以拥有互斥对象，对被保护资源进行访问
19. void Mutex::Unlock() const
20. {
21. ::ReleaseMutex(m_mutex);
22. }
23. //---------------------------------------------------------------------------
24. //初始化临界资源对象
25. CriSection::CriSection()
26. {
27. ::InitializeCriticalSection(&m_critclSection);
28. }
29. //释放临界资源对象
30. CriSection::~CriSection()
31. {
32. ::DeleteCriticalSection(&m_critclSection);
33. }
34. //进入临界区，加锁
35. void CriSection::Lock() const
36. {
37. ::EnterCriticalSection((LPCRITICAL_SECTION)&m_critclSection);
38. }
39. //离开临界区，解锁
40. void CriSection::Unlock() const
41. {
42. ::LeaveCriticalSection((LPCRITICAL_SECTION)&m_critclSection);
43. }
44. //---------------------------------------------------------------------------
45. //利用C++特性，进行自动加锁
46. CMyLock::CMyLock(const ILock& m) : m_lock(m)
47. {
48. m_lock.Lock();
49. }
50. //利用C++特性，进行自动解锁
51. CMyLock::~CMyLock()
52. {
53. m_lock.Unlock();
54. }

下边是测试代码

[cpp] view plaincopy

1. // MyLock.cpp : 定义控制台应用程序的入口点。
2. //
3. #include <iostream>
4. #include <process.h>
5. #include <time.h>
6. #include "Lock.h"
7. using namespace std;
8. #define ENABLE_MUTEX
9. #define ENABLE_CRITICAL_SECTION
10. #if defined (ENABLE_MUTEX)
11. //创建一个互斥对象类型锁
12. Mutex g_Lock;
13. #elif defined (ENABLE_CRITICAL_SECTION)
14. //创建一个临界区类型锁
15. CriSection g_Lock;
16. #endif
17. void LockCompare(int &iNum)
18. {
19. CMyLock lock1(g_Lock);
20. iNum++;
21. }
22. //线程函数
23. unsigned int __stdcall StartThread(void *pParam)
24. {
25. char *pMsg = (char *)pParam;
26. if (!pMsg)
27. {
28. return (unsigned int)1;
29. }
30. CMyLock lock2(g_Lock);
31. clock_t tStart,tEnd;
32. tStart = clock();
33. int iNum = 0;
34. for (int i = 0; i < 100000; i++)
35. {
36. LockCompare(iNum);
37. }
38. tEnd = clock();
39. #if defined (ENABLE_MUTEX)
40. cout<<"The lock type is mutex, time = "<<(tEnd - tStart)<<" ms."<<endl;
41. #elif defined (ENABLE_CRITICAL_SECTION)
42. cout<<"The lock type is critical section, time = "<<(tEnd - tStart)<<" ms."<<endl;
43. #endif
44. return (unsigned int)0;
45. }
46. int main(int argc, char* argv[])
47. {
48. HANDLE hThread1, hThread2;
49. unsigned int uiThreadId1, uiThreadId2;
50. char *pMsg1 = "First print thread.";
51. char *pMsg2 = "Second print thread.";
52. //创建两个工作线程，分别打印不同的消息
53. hThread1 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)pMsg1, 0, &uiThreadId1);
54. hThread2 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)pMsg2, 0, &uiThreadId2);
55. //等待线程结束
56. DWORD dwRet = WaitForSingleObject(hThread1,INFINITE);
57. if ( dwRet == WAIT_TIMEOUT )
58. {
59. TerminateThread(hThread1,0);
60. }
61. dwRet = WaitForSingleObject(hThread2,INFINITE);
62. if ( dwRet == WAIT_TIMEOUT )
63. {
64. TerminateThread(hThread2,0);
65. }
66. //关闭线程句柄，释放资源
67. ::CloseHandle(hThread1);
68. ::CloseHandle(hThread2);
69. system("pause");
70. return 0;
71. }

在线程函数StartThread中，循环100000次，对保护资源“iNum ”反复加锁，解锁。编译，运行5次，将每次打印的线程锁切换耗时时间记录下来。之后，将测试代码中的宏 #define ENABLE_MUTEX 注释掉，禁掉互斥锁，启用临界区锁，重新编译代码，运行5次。下边是分别是互斥锁和临界区锁耗时记录（不同机器上耗时会不同）：

互斥锁

临界区锁

互斥锁总共耗时：641+686=1327 ms，而临界区锁：124+140=264 ms。显而易见，临界区锁耗时比互斥锁耗时节约了大概5倍的时间。

总结：1、在同一个进程的多线程同步锁，宜用临界区锁，它比较节约线程上下文切换带来的系统开销。但因临界区工作在用户模式下，所以不能对不同进程中的多线程进行同步。2、因互斥对象锁属于内核对象，所以在进行多线程同步时速度会比较慢，但是可以在不同进程的多个线程之间进行同步。