【转】用C++实现多线程Mutex锁（Win32）

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

本文目的：用C++和Windows的互斥对象（Mutex）来实现线程同步锁。

准备知识：1，内核对象互斥体（Mutex）的工作机理，WaitForSingleObject函数的用法，这些可以从MSDN获取详情； 2，当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。Mutex 是同步基元，它只向一个线程授予对共享资源的独占访问权。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。

下边是我参考开源项目C++ Sockets的代码，写的线程锁类

Lock.h

[cpp] view plaincopy

1. #ifndef _Lock_H
2. #define _Lock_H
3. #include <windows.h>
4. //锁接口类
5. class IMyLock
6. {
7. public:
8. virtual ~IMyLock() {}
9. virtual void Lock() const = 0;
10. virtual void Unlock() const = 0;
11. };
12. //互斥对象锁类
13. class Mutex : public IMyLock
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 CLock
25. {
26. public:
27. CLock(const IMyLock&);
28. ~CLock();
29. private:
30. const IMyLock& m_lock;
31. };
32. #endif

Lock.cpp

[cpp] view plaincopy

1. #include "Lock.h"
2. //创建一个匿名互斥对象
3. Mutex::Mutex()
4. {
5. m_mutex = ::CreateMutex(NULL, FALSE, NULL);
6. }
7. //销毁互斥对象，释放资源
8. Mutex::~Mutex()
9. {
10. ::CloseHandle(m_mutex);
11. }
12. //确保拥有互斥对象的线程对被保护资源的独自访问
13. void Mutex::Lock() const
14. {
15. DWORD d = WaitForSingleObject(m_mutex, INFINITE);
16. }
17. //释放当前线程拥有的互斥对象，以使其它线程可以拥有互斥对象，对被保护资源进行访问
18. void Mutex::Unlock() const
19. {
20. ::ReleaseMutex(m_mutex);
21. }
22. //利用C++特性，进行自动加锁
23. CLock::CLock(const IMyLock& m) : m_lock(m)
24. {
25. m_lock.Lock();
26. }
27. //利用C++特性，进行自动解锁
28. CLock::~CLock()
29. {
30. m_lock.Unlock();
31. }

下边是测试代码

[cpp] view plaincopy

1. // MyLock.cpp : 定义控制台应用程序的入口点。
2. //
3. #include <iostream>
4. #include <process.h>
5. #include "Lock.h"
6. using namespace std;
7. //创建一个互斥对象
8. Mutex g_Lock;
9. //线程函数
10. unsigned int __stdcall StartThread(void *pParam)
11. {
12. char *pMsg = (char *)pParam;
13. if (!pMsg)
14. {
15. return (unsigned int)1;
16. }
17. //对被保护资源（以下打印语句）自动加锁
18. //线程函数结束前，自动解锁
19. CLock lock(g_Lock);
20. for( int i = 0; i < 5; i++ )
21. {
22. cout << pMsg << endl;
23. Sleep( 500 );
24. }
25. return (unsigned int)0;
26. }
27. int main(int argc, char* argv[])
28. {
29. HANDLE hThread1, hThread2;
30. unsigned int uiThreadId1, uiThreadId2;
31. char *pMsg1 = "First print thread.";
32. char *pMsg2 = "Second print thread.";
33. //创建两个工作线程，分别打印不同的消息
34. //hThread1 = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)StartThread, (void *)pMsg1, 0, (LPDWORD)&uiThreadId1);
35. //hThread2 = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)StartThread, (void *)pMsg2, 0, (LPDWORD)&uiThreadId2);
36. hThread1 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)pMsg1, 0, &uiThreadId1);
37. hThread2 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)pMsg2, 0, &uiThreadId2);
38. //等待线程结束
39. DWORD dwRet = WaitForSingleObject(hThread1,INFINITE);
40. if ( dwRet == WAIT_TIMEOUT )
41. {
42. TerminateThread(hThread1,0);
43. }
44. dwRet = WaitForSingleObject(hThread2,INFINITE);
45. if ( dwRet == WAIT_TIMEOUT )
46. {
47. TerminateThread(hThread2,0);
48. }
49. //关闭线程句柄，释放资源
50. ::CloseHandle(hThread1);
51. ::CloseHandle(hThread2);
52. system("pause");
53. return 0;
54. }

用VC2005编译，启动程序，下边是截图

如果将测线程函数中的代码注视掉，重新编译代码，运行

[cpp] view plaincopy

1. CLock lock(g_Lock);

则结果见下图

由此可见，通过使用Mutex的封装类，即可达到多线程同步的目的。因Mutex属于内核对象，所以在进行多线程同步时速度会比较慢，但是用互斥对象可以在不同进程的多个线程之间进行同步。

在实际应用中，我们通常还会用到临界区，也有叫做关键代码段的CRITICAL_SECTION，在下篇博客中，我将会把CRITICAL_SECTION锁添加进来，并且对Mutex和CRITICAL_SECTION的性能做以比较。