用C++实现多线程Mutex锁 |chexlong

winston

  本文目的：用C++和Windows的互斥对象（Mutex）来实现线程同步锁。
    准备知识：1，内核对象互斥体（Mutex）的工作机理，WaitForSingleObject函数的用法，这些可以从MSDN获取详情； 2，当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。Mutex 是同步基元，它只向一个线程授予对共享资源的独占访问权。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。
    下边是我参考开源项目C++ Sockets的代码，写的线程锁类
Lock.h

1. #ifndef _Lock_H
2. #define _Lock_H
4. #include <windows.h>
6. //锁接口类
7. class IMyLock
8. {
9. public:
10.         virtual ~IMyLock() {}
12.         virtual void Lock() const = 0;
13.         virtual void Unlock() const = 0;
14. };
16. //互斥对象锁类
17. class Mutex : public IMyLock
18. {
19. public:
20.         Mutex();
21.         ~Mutex();
23.         virtual void Lock() const;
24.         virtual void Unlock() const;
26. private:
27.         HANDLE m_mutex;
28. };
30. //锁
31. class CLock
32. {
33. public:
34.         CLock(const IMyLock&);
35.         ~CLock();
37. private:
38.         const IMyLock& m_lock;
39. };
42. #endif
44. Lock.cpp#include "Lock.h"
46. //创建一个匿名互斥对象
47. Mutex::Mutex()
48. {
49.         m_mutex = ::CreateMutex(NULL, FALSE, NULL);
50. }
52. //销毁互斥对象，释放资源
53. Mutex::~Mutex()
54. {
55.         ::CloseHandle(m_mutex);
56. }
58. //确保拥有互斥对象的线程对被保护资源的独自访问
59. void Mutex::Lock() const
60. {
61.         DWORD d = WaitForSingleObject(m_mutex, INFINITE);
62. }
64. //释放当前线程拥有的互斥对象，以使其它线程可以拥有互斥对象，对被保护资源进行访问
65. void Mutex::Unlock() const
66. {
67.         ::ReleaseMutex(m_mutex);
68. }
70. //利用C++特性，进行自动加锁
71. CLock::CLock(const IMyLock& m) : m_lock(m)
72. {
73.         m_lock.Lock();
74. }
76. //利用C++特性，进行自动解锁
77. CLock::~CLock()
78. {
79.         m_lock.Unlock();
80. }

复制代码

    下边是测试代码

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

复制代码

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

    如果将测线程函数中的代码注视掉，重新编译代码，运行
CLock lock(g_Lock);
     则结果见下图

    由此可见，通过使用Mutex的封装类，即可达到多线程同步的目的。因Mutex属于内核对象，所以在进行多线程同步时速度会比较慢，但是用互斥对象可以在不同进程的多个线程之间进行同步。
    在实际应用中，我们通常还会用到关键代码段CRITICAL_SECTION，在下篇博客中，我将会把关键代码段锁添加进来，并且对Mutex和CRITICAL_SECTION的性能做以比较。

作者：chexlong 发表于2011-12-7 20:38:57 原文链接

iq50

CRITICAL_SECTION会先自旋2000次再调用内核对象，BOOST库用内核对象实现了类似CRITICAL_SECTION的锁，那代码还是值得看看。