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

SHForWork

墨衍会员 · AI 创作全网分发码龄12年

关注

转载最新推荐文章于 2026-03-08 17:50:38 发布 765 阅读 AI 写同款· GEO 优化 ›

AI权益加码！Claude Code、Cursor等20+工具免费用！购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！阅读详情

转自http://blog.csdn.net/chexlong/article/details/7051193

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

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

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

Lock.h

[cpp]view plaincopy 
   
 #ifndef _Lock_H  
 #define _Lock_H  
   
 #include <windows.h>  
   
 //锁接口类  
 class IMyLock  
 {  
 public:  
     virtual ~IMyLock() {}  
   
     virtual void Lock() const = 0;  
     virtual void Unlock() const = 0;  
 };  
   
 //互斥对象锁类  
 class Mutex : public IMyLock  
 {  
 public:  
     Mutex();  
     ~Mutex();  
   
     virtual void Lock() const;  
     virtual void Unlock() const;  
   
 private:  
     HANDLE m_mutex;  
 };  
   
 //锁  
 class CLock  
 {  
 public:  
     CLock(const IMyLock&);  
     ~CLock();  
   
 private:  
     const IMyLock& m_lock;  
 };  
   
   
 #endif  

Lock.cpp

[cpp]view plaincopy 
   
 #include "Lock.h"  
   
 //创建一个匿名互斥对象  
 Mutex::Mutex()  
 {  
     m_mutex = ::CreateMutex(NULL, FALSE, NULL);  
 }  
   
 //销毁互斥对象，释放资源  
 Mutex::~Mutex()  
 {  
     ::CloseHandle(m_mutex);  
 }  
   
 //确保拥有互斥对象的线程对被保护资源的独自访问  
 void Mutex::Lock() const  
 {  
     DWORD d = WaitForSingleObject(m_mutex, INFINITE);  
 }  
   
 //释放当前线程拥有的互斥对象，以使其它线程可以拥有互斥对象，对被保护资源进行访问  
 void Mutex::Unlock() const  
 {  
     ::ReleaseMutex(m_mutex);  
 }  
   
 //利用C++特性，进行自动加锁  
 CLock::CLock(const IMyLock& m) : m_lock(m)  
 {  
     m_lock.Lock();  
 }  
   
 //利用C++特性，进行自动解锁  
 CLock::~CLock()  
 {  
     m_lock.Unlock();  
 }  

下边是测试代码

[cpp]view plaincopy 
   
 // MyLock.cpp : 定义控制台应用程序的入口点。  
 //  
   
 #include <iostream>  
 #include <process.h>  
 #include "Lock.h"  
   
 using namespace std;  
   
 //创建一个互斥对象  
 Mutex g_Lock;  
   
   
 //线程函数  
 unsigned int __stdcall StartThread(void *pParam)  
 {  
     char *pMsg = (char *)pParam;  
     if (!pMsg)  
     {  
         return (unsigned int)1;  
     }  
   
     //对被保护资源（以下打印语句）自动加锁  
     //线程函数结束前，自动解锁  
     CLock lock(g_Lock);  
   
     for( int i = 0; i < 5; i++ )  
     {  
         cout << pMsg << endl;  
         Sleep( 500 );  
     }  
   
     return (unsigned int)0;  
 }  
   
 int main(int argc, char* argv[])  
 {  
     HANDLE hThread1, hThread2;  
     unsigned int uiThreadId1, uiThreadId2;  
   
     char *pMsg1 = "First print thread.";  
     char *pMsg2 = "Second print thread.";  
   
     //创建两个工作线程，分别打印不同的消息  
   
     //hThread1 = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)StartThread, (void *)pMsg1, 0, (LPDWORD)&uiThreadId1);  
     //hThread2 = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)StartThread, (void *)pMsg2, 0, (LPDWORD)&uiThreadId2);  
   
     hThread1 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)pMsg1, 0, &uiThreadId1);  
     hThread2 = (HANDLE)_beginthreadex(NULL, 0, &StartThread, (void *)pMsg2, 0, &uiThreadId2);  
   
     //等待线程结束  
     DWORD dwRet = WaitForSingleObject(hThread1,INFINITE);  
     if ( dwRet == WAIT_TIMEOUT )  
     {  
         TerminateThread(hThread1,0);  
     }  
     dwRet = WaitForSingleObject(hThread2,INFINITE);  
     if ( dwRet == WAIT_TIMEOUT )  
     {  
         TerminateThread(hThread2,0);  
     }  
   
     //关闭线程句柄，释放资源  
     ::CloseHandle(hThread1);  
     ::CloseHandle(hThread2);  
   
     system("pause");  
     return 0;  
 }  

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

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

[cpp]view plaincopy 
   
 CLock lock(g_Lock);  

则结果见下图

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

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

收录于

其他

标签

#mutex

C++多线程同步之Mutex(互斥量) 一、互斥量Mutex同步多线程1、Win32平台相关函数和头文件#include <windows.h> HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针 BOOLbInitialOwner, // 初始化互斥对象的所有者 LPCTSTRlpName // 指向互斥对象名的指针 );DWORD WINAP 阅读详情

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

相关推荐