C++多线程实例之互斥量同步_c++ 多线程调用同一个成员函数-优快云博客

本文介绍了一种跨平台的互斥量封装方法，支持Windows和Linux系统，并提供了多线程生产者-消费者模式下的应用实例。通过封装互斥量和条件变量为CMutexLock类，简化了多线程同步的复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

要点：将互斥量 + 条件变量/事件对象封装为了一个类CMutexLock,该类同时支持windows和linux下的互斥量同步。对熟悉windows和linux下面的多线程开发很有帮助。下面的代码可以直接在VS2008,2010中编译通过，linux下也是没问题的。如果你觉得写得不错也可以直接移植到你的代码库中，比较适合多线程中采用生产者-消费者这样的场景，比如子线程读取和解析文件生产给其它线程用，网络接收子线程接收处理数据给其它线程使用等。

强烈建议有需要的跑起来调试下(本项目类型是VS win32项目cpp中需要#include "stdafx.h"，其它类型项目或者linux下简单修改下即可)，代码注释中有详细的说明。如果你觉得有更好的做法，或者那里注释错了，非常欢迎你的回复。本代码也是参考了很多网上的资料，感谢参考文章中的各位作者。

工程设置：

1.pthread多线程库使用：

pthread库源代码:ftp://sources.redhat.com/pub/pthreads-win32/
本项目下载的是：pthreads-w32-2-9-1-release.zip 解压Pre-built.2就是要包含的库，pthreadVC2.dll拷贝到C:\Windows\System32下。

VC工程设置：
头文件:../../pthreads-w32-2-9-1-release\Pre-built.2\include
库目录：../../pthreads-w32-2-9-1-release\Pre-built.2\lib\x86
库：pthreadVC2.lib
代码包含头文件：#include <pthread.h>

2.windows下
VC工程设置ProjectàSetting-->C/C++-->Code generation->run-time library 选择Multi-threaded 或者Multithreaded。
即使用: MT或MD。
代码包含头文件：
#include <Windows.h>
#include <process.h>

多线程代码：

例子，具体用法和分析见代码注释：

MutexLock.h

[cpp]view plain copy
#ifndef _MUTEXLOCK_H_  
#define _MUTEXLOCK_H_  
  
#ifdef WIN32  
//#define WINOS // 这里可以注释掉就是linux形式的互斥量  
#else  
#undef  WINOS  
#endif  
  
#ifdef WINOS  
#include <Windows.h>  
#include <process.h>   
#else  
#include <pthread.h>  
//来自ftp://sources.redhat.com/pub/pthreads-win32/  
/* 获取互斥量属性对象在进程间共享与否的标志  
int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *__restrict __attr, \   
                                  int *__restrict __pshared);   
 设置互斥量属性对象，标识在进程间共享与否 
int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, int __pshared);  
底层库都像一个状态机，包括socket,pthread,directx,opengl,openal... 
这是对外统一接口，松耦合，但是又可能需要调整内部的参数，那么必须采用这样的方式，不论编写的语言是基于过程还是基于对象的。 
 */  
/*参考文章:http://www.ibm.com/developerworks/cn/linux/l-cn-mthreadps/ 
http://blog.youkuaiyun.com/anonymalias/article/details/9093733 
https://software.intel.com/zh-cn/blogs/2011/03/24/linux-windows 
*/  
#endif  
  
class CMutexLock  
{  
public:  
    CMutexLock();  
    ~CMutexLock();  
    void init();  
    void release();  
    void lock();  
    void unlock();// 设计的时候，不要unwaite放置到unlock里面去，否则会导致职责不分明，如果有内部控制的还会导致无法唤醒。  
    void waite();// 当获取不到数据，那么waite挂起线程，等待其它线程通知释放  
    void unwaite();// 生产了数据那么需要调用unwaite.  
private:  
    #ifdef WINOS  
        HANDLE m_mutex;  
        HANDLE m_event;//事件如果有信号那么可以正常执行，如果无信号那么只能等待  
    #else  
        pthread_mutex_t m_mutex;  
        pthread_cond_t m_condition;  
        pthread_mutexattr_t m_mutexAttr;  
    #endif  
};  
  
#endif  

MutexLock.cpp

[cpp]view plain copy
#include "stdafx.h"  
#include "MutexLock.h"  
/*参考文章： 
https://msdn.microsoft.com/en-us/library/windows/desktop/ms682411%28v=vs.85%29.aspx 
http://blog.youkuaiyun.com/anonymalias/article/details/9080881 
http://blog.youkuaiyun.com/anonymalias/article/details/9174403 
*/  
CMutexLock::CMutexLock()  
{  
      
#ifndef WINOS  
    m_mutex = NULL;  
    m_condition = NULL;  
#else  
    m_mutex = NULL;  
    m_event = NULL;  
#endif  
}  
CMutexLock::~CMutexLock()  
{  
    release();  
}  
void CMutexLock::release()  
{  
#ifdef WINOS  
    CloseHandle(m_mutex);//所有内核对象，或者用其它方式创建的，都可以用closeHandle将引用计数减1。  
    m_mutex = NULL;  
#else  
    pthread_mutexattr_destroy(&m_mutexAttr);  
    pthread_mutex_destroy(&m_mutex);  
    pthread_cond_destroy(&m_condition);  
    m_mutex = NULL;  
    m_condition = NULL;  
#endif  
}  
  
void CMutexLock::init()  
{  
#ifdef WINOS  
    // arg1 是NULL,互斥量用默认的安全描述信息,这个时候子进程不能继承该互斥量.  
    // arg2 是当前指明互斥量指向的线程为空,且被引用的次数是0，没有线程/进程拥有该互斥量；否则当前线程拥有该互斥量。  
    // arg3 互斥量的名字  
    m_mutex = CreateMutex(NULL, FALSE, NULL);  
    DWORD dwLastError = GetLastError();  
    if( dwLastError == ERROR_ALREADY_EXISTS)  
    {  
        CloseHandle(m_mutex);  
        m_mutex = NULL;  
    }  
    //事件是有信号线程不阻塞，无信号阻塞线程睡眠。  
    // arg1是事件属性。  
    // arg2是手动还是自动调用ResetEvent将事件设置为无信号,SetEvent是将事件设置为有信号  
    // ResetEvent是否手动设置为无信号,WaitForSingleObject后如果是自动方式那么会自动调用ResetEvent将事件设置为无信号。  
    // arg3是初始状态信号，一般设置为FALSE无信号，让线程挂起阻塞。  
    // arg4是线程的名字。  
    m_event = CreateEvent(NULL, FALSE, FALSE, NULL);  
#else  
    // arg1是初始化的互斥量，arg2是pthread_mutexattr_t属性指针，如果是NULL,那么没有线程拥有该初始化好的互斥量。  
    int nResult = pthread_mutex_init(&m_mutex, NULL);  
    if(nResult == 0)  
     {  
         printf("pthread_mutex_init result OK.\n");  
     }  
     else  
     {  
         printf("pthread_mutex_init result error:%d\n", nResult);  
     }  
    pthread_mutexattr_init(&m_mutexAttr);   
    // 设置 recursive 属性,使得linux下可以递归加锁，避免递归加锁死锁。  
    pthread_mutexattr_settype(&m_mutexAttr,PTHREAD_MUTEX_RECURSIVE_NP);   
    pthread_mutex_init(&m_mutex, &m_mutexAttr);  
  
    pthread_cond_init(&m_condition, NULL);  
#endif  
}  
  
void CMutexLock::lock()  
{  
#ifdef WINOS  
    // arg2是等待毫秒时间，INFINITE是永远等待，直到该内核对象被触发可用；该函数是一个异步调用函数，互斥量拥有线程id非0，  
    // 那么该函数将被挂起阻塞，释放当前CPU拥有权，当被其它线程释放互斥量拥有线程id为0，将会唤醒当前阻塞的线程重新获取互斥量。  
    WaitForSingleObject(m_mutex, INFINITE);  
    /*if(WaiteforSingleObject(m_hMutex, dwMilliSec) == WAIT_OBJECT_0) 
    { 
        return true; 
    } 
    return false; 
    */  
#else  
    // 锁定互斥锁，如果该互斥锁被其它线程拥有，那么将被挂起阻塞，指定可用才回调返回；  
    // 线程自己多次锁定将会导致死锁；两个线程需要多个互斥锁相互等待对方的互斥锁，也会导致死锁。  
    pthread_mutex_lock(&m_mutex);   
#endif  
}  
  
void  CMutexLock::waite()  
{  
#ifdef WINOS  
    WaitForSingleObject(m_event, INFINITE);// 等待的事件，和时间  
#else  
    //会自动调用pthread_mutex_unlock(&m_mutex)释放互斥量，将当前线程挂起阻塞，等待对方线程pthread_cond_signal通知唤醒，  
    // 唤醒后pthread_cond_wait会调用pthread_mutex_lock重新锁定互斥量。  
    // pthread_cond_timedwait是阻塞一段时间。  
    pthread_cond_wait(&m_condition, &m_mutex);  
#endif  
}  
  
void CMutexLock::unwaite()  
{  
#ifdef WINOS  
    SetEvent(m_event);//设置为有信号，唤醒等待事件挂起的线程。  
#else  
    pthread_cond_signal(&m_condition);//pthread_cond_broadcast(pthread_cond_t * cond)唤醒在条件上等待的所有线程。  
#endif  
  
}  
  
void CMutexLock::unlock()  
{  
#ifdef WINOS  
    ReleaseMutex(m_mutex);// 将互斥量释放,会通知到WaitForSingleObject.  
#else  
    pthread_mutex_unlock(&m_mutex);  
#endif  
}  

main.cpp

[cpp]view plain copy
/*多线程的一些总结： 
一、互斥量是拥有线程ID的，如果互斥量没有线程ID那么当前线程可以获得互斥量，互斥量函数非阻塞；否则互斥量函数将阻塞当前线程。 
    linux下条件变量初始化时是没有绑定互斥量的（无信号的)，只要waite都会释放当前互斥量，阻塞当前线程，直到有signal发送过来才会唤醒。 
    window下的事件对象，事件对象无信号情况下会阻塞当前线程，通过SetEvent(m_event)可以触发事件(signal)，让当前阻塞的线程唤醒。 
二、采用等待机制等有效的提高程序的CPU利用率，注意等待时需要先释放所用拥有的锁(尽管之前释放过,），否则会导致死锁。 
s_mutexFileContent.unlock();// 不加这句linux的pthread库会导致死锁，linux不能递归加锁否则会导致死锁，windows下却可以。 
s_mutexRequent.unlock(); // 不加这句，windows下的WaitForSingleObject不会先释放互斥量锁，也会导致死锁。 
 
//s_mutexRequent.waite(); 
三、pthread.h库下默认创建的线程是可结合的，每个可结合线程都应该要么被显示地回收，即调用pthread_join； 
要么通过调用pthread_detach函数分离子线程，子线程被分离后不能再结合了。 
pthread_detach(s_loadingThread); 
 
四、window下的WaitForSingleObject线程未运行时候是未触发的，当线程运行完那么是触发的，所以可以等到到线程。 
//返回WAIT_OBJECT_0在指定时间内等到到，WAIT_TIMEOUT超时，WAIT_FAILED有错误。 
HANDLE handle = CreateThread(NULL, 0, ThreadFun, NULL, 0, NULL);   
WaitForSingleObject(handle, INFINITE); 
五、windows下众多多线程函数的选择；_beginthread是_beginthreadex的子集参数受限制，释放会有差异，所以用_beginthreadex即可。 
_beginthreadex内部会调用CreateThread()，会给C运行库函数开辟堆资源，所以要用_endthreadex和CloseHandle来避免内存泄露。 
CreateThread()没有开辟堆资源，所以在C运行库中可能导致多线程数据异常风险，但是在Win32/MFC C++运行库中可以放心使用。 
AfxBeginThread()是MFC中的多线程，分工作线程无消息循环，界面线程有消息循环，可以让当前线程创建，挂起，唤醒，终止。 
windows下线程常用函数：DWORD SuspendThread(HANDLE hThread);DWORD ResumeThread(HANDLE hThread);BOOL SetThreadPriority(HANDLE hThread,int nPriority); 
VOID ExitThread(DWORD dwExitCode); BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);  
一般线程的挂起/唤醒都通过同步对象来实现。 
 
如果在代码中有使用标准C运行库中的函数时，尽量使用_beginthreadex()来代替CreateThread()。 
window下的多线程底层都是对CreateThread的封装。 
如果在除主线程之外的任何线程中进行一下操作，你就应该使用多线程版本的C runtime library,并使用_beginthreadex和_endthreadex，CloseHandle： 
1 使用malloc()和free()，或是new和delete 
2 使用stdio.h或io.h里面声明的任何函数 
3 使用浮点变量或浮点运算函数 
4 调用任何一个使用了静态缓冲区的runtime函数，比如:asctime(),strtok()或rand() 
 
六、linux和window下互斥量和条件变量的区别 
1.linux连续上锁会死锁，可以用 pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP); 解决。windows连续上锁不会死锁。 
2.SetEvent(m_event)后等待事件对象一直是有signal的，后面waite的不会阻塞；linux下pthread_cond_signal不会一直有信号，后面waite的将会阻塞。 
3.pthread_cond_wait()后不需要重新加锁，WaitForSingleObject/SignalObjectAndWait后需要重新加锁。 
4.linux的pthread_cond_timedwait等待的是绝对时间1970-01-01 00:00:00 开始的时间，window的WaitForSingleObject是一个从当前开始的相对时间。  
5.linux的线程释放，非游离的线程需要主线程调用pthread_join等待子线程结束并释放子线程的栈寄存器，游离的线程需要设置为属性为游离， 
或者创建后用pthread_detach设置，子线程结束时候系统会回收子线程的资源。这样才能避免内存泄露。 
windows下的释放：_beginthreadex创建的要调用_endthreadex和CloseHandle，其它方式创建的线程ExitThread或CloseHanle即可。 
*/  
#include "stdafx.h"  
#include "MutexLock.h"  
#include <iostream>  
#include <deque>  
#include <string>  
using namespace std;  
#include <windows.h>  
  
// 异步线程  
#ifdef WINOS  
static HANDLE s_loadingThread = NULL;  
#else  
static pthread_t s_loadingThread;  
#endif  
// 异步读取文件的互斥量  
static CMutexLock s_mutexRequent;  
// 异步渲染的互斥量  
static CMutexLock s_mutexFileContent;  
  
// 根对象，派生Node  
class Object  
{  
public:  
    Object()  
    {  
        m_dObjID = 0;  
    }  
protected:  
    double m_dObjID;  
};  
// 异步加载后的回调函数  
typedef  void (* ObjectCallBack)(Object* );  
  
typedef struct tagAsyncFileData  
{  
    bool m_bLoadOK;  
    Object *m_pTarget;  
    ObjectCallBack m_pCallback;  
    string strFilePath;  
    tagAsyncFileData()  
    {  
        m_bLoadOK = false;  
        m_pTarget = NULL;  
        m_pCallback = NULL;  
        strFilePath.clear();  
    }  
}AsyncFileData;  
  
static deque<AsyncFileData*> s_dataFileRequent;  
  
typedef struct tagFileBufferData  
{  
    AsyncFileData *m_pAsyncFileData;  
    char *m_pBuffer;  
    tagFileBufferData()  
    {  
        m_pAsyncFileData = NULL;  
        m_pBuffer = NULL;  
    }  
}AsyncFileBufferData;  
  
static deque<AsyncFileBufferData*> s_dataFileContent;  
  
#ifdef WINOS  
unsigned __stdcall AsyncLoad(void *pParameter)    
#else  
static void* AsyncLoad(void *pParameter)  
#endif  
{  
    while(1)  
    {  
        AsyncFileData *pFileData = NULL;  
        s_mutexRequent.lock();  
        if(s_dataFileRequent.empty())  
        {  
            // 如果没有数据过来那么释放当前的锁，挂起CPU等待  
            printf("子线程，因没有请求的文件而等待!\n");  
            s_mutexFileContent.unlock();// 不加这句linux的pthread库会导致死锁。  
            s_mutexRequent.unlock(); // 不加这句，windows下的WaitForSingleObject不会先释放互斥量锁，也会导致死锁。  
            s_mutexRequent.waite();  
              
            continue;  
        }  
        else  
        {  
            pFileData = s_dataFileRequent.front();  
            s_dataFileRequent.pop_front();  
        }  
        s_mutexRequent.unlock();  
          
  
        // 得到数据处理  
        if(pFileData != NULL)  
        {  
            // 异步加载数据，此次mmap还是fread方式略去，直接设置加载OK  
            //fopen(pFileData->strFilePath.c_str(), "rb");  
            Sleep(1000);  
            pFileData->m_bLoadOK = true;  
            //pFileData.m_pTarget  
            AsyncFileBufferData *pAsyncBuffer  = new AsyncFileBufferData;  
            pAsyncBuffer->m_pAsyncFileData = pFileData;  
            char *pContent = "data from pFileData's strFilePath...";  
            int nContenLen = strlen(pContent) + 1;  
            pAsyncBuffer->m_pBuffer = new char[nContenLen];  
            strcpy_s(pAsyncBuffer->m_pBuffer, nContenLen, pContent);  
            printf("子线程 读取文件: %s\n", pAsyncBuffer->m_pAsyncFileData->strFilePath.c_str());  
              
            // 异步处理锁  
            s_mutexFileContent.lock();  
            // 解析好的数据放置进来  
            s_dataFileContent.push_back(pAsyncBuffer);  
            s_mutexFileContent.unlock();  
            s_mutexFileContent.unwaite();  
        }  
    }  
#ifdef WINOS  
    _endthreadex( 0 );// 释放_beginthreadex分配的堆资源，且还要用CloseHandle释放  
    return 0;  
#endif  
}  
  
int main(int argc, char* argv[])    
{   
    s_mutexRequent.init();  
    s_mutexFileContent.init();  
#ifdef WINOS  
    unsigned int uiThreadID;  
    s_loadingThread = (HANDLE)_beginthreadex(NULL, 0, AsyncLoad, NULL, CREATE_SUSPENDED, &uiThreadID);   
    /*_CRTIMP uintptr_t __cdecl _beginthreadex(_In_opt_ void * _Security, _In_ unsigned _StackSize, 
        _In_ unsigned (__stdcall * _StartAddress) (void *), _In_opt_ void * _ArgList,  
        _In_ unsigned _InitFlag, _In_opt_ unsigned * _ThrdAddr);*/  
    if(s_loadingThread == NULL)  
    {  
        printf("pthread_create error!");  
        return 0;  
    }  
    ResumeThread(s_loadingThread);   
#else  
    if( pthread_create(&s_loadingThread, NULL, AsyncLoad, NULL) != 0)  
    {  
        printf("pthread_create error!");  
        return 0;  
    }  
    pthread_detach(s_loadingThread);  
#endif  
    // 在任何一个时间点上，线程是可结合的（joinable）或者是分离的（detached）。一个可结合的线程能够被其他线程收回其资源和杀死。  
    // 在被其他线程回收之前，它的存储器资源（例如栈）是不释放的。相反，一个分离的线程是不能被其他线程回收或杀死的，  
    // 它的存储器资源在它终止时由系统自动释放。默认情况下，线程被创建成可结合的。为了避免存储器泄漏，  
    // 每个可结合线程都应该要么被显示地回收，即调用pthread_join；要么通过调用pthread_detach函数被分离。  
  
    // pthread_detach(s_loadingThread);分离，运行结束后子线程会自动释放自己资源，不需要pthread_join也可以完全释放资源。  
    //   void* ret = NULL;  
    // pthread_join(_subThreadInstance, &ret);主线程一直等待直到等待的线程结束自己才结束，主线程可以清理其它线程的栈寄存器。  
    // pthread_self()获取自身线程的id.  
    // 线程的被动结束分为两种，一种是异步终结，另外一种是同步终结。异步终结就是当其他线程调用 pthread_cancel的时候，  
    // 线程就立刻被结束。而同步终结则不会立刻终结，它会继续运行，直到到达下一个结束点（cancellation point）。  
    // 当一个线程被按照默认的创建方式创建，那么它的属性是同步终结。  
    static int fileCount = 0;  
    while(1)  
    {  
        s_mutexRequent.lock();  
        AsyncFileData* m_pFileData = new AsyncFileData();  
        m_pFileData->m_bLoadOK = false;  
        m_pFileData->m_pCallback = NULL;  
        m_pFileData->m_pTarget = NULL;  
        fileCount++;  
        char szFileBuffer[256];  
        sprintf_s(szFileBuffer,"文件名 %d.", fileCount);  
        m_pFileData->strFilePath = szFileBuffer;  
        printf("主线程，请求读取文件: %s\n", m_pFileData->strFilePath.c_str());  
        s_dataFileRequent.push_back(m_pFileData);  
        s_mutexRequent.unlock();  
        s_mutexRequent.unwaite();  
  
        // 其它逻辑  
        Sleep(1000);  
  
        while(1)  
        {  
            AsyncFileBufferData *pAsyncBuffer = NULL;  
  
            s_mutexFileContent.lock();  
            if(s_dataFileContent.empty())  
            {  
                printf("主线程，因没有解析好的数据等待!\n");  
                s_mutexRequent.unlock();// 请求锁需要释放，否则会导致问题  
                s_mutexFileContent.unlock();  
                s_mutexFileContent.waite();// 读取线程还没解析好等待  
                continue;  
            }  
  
            pAsyncBuffer = s_dataFileContent.front();  
            s_dataFileContent.pop_front();  
            s_mutexFileContent.unlock();  
  
            if(pAsyncBuffer != NULL)  
            {  
                printf("主线程，得到读取线程解析后的文件：%s, 数据: %s\n", pAsyncBuffer->m_pAsyncFileData->strFilePath.c_str(), pAsyncBuffer->m_pBuffer);  
                delete pAsyncBuffer->m_pAsyncFileData;  
                delete [] pAsyncBuffer->m_pBuffer;  
                delete pAsyncBuffer;  
                pAsyncBuffer = NULL;  
  
                // 其它逻辑  
                Sleep(1000);  
                break;  
            }     
        }// end while 2  
      
    } //  end while 1  
  
    s_mutexRequent.release();  
    s_mutexFileContent.release();  
#ifdef WINOS  
    CloseHandle(s_loadingThread);  
#else  
    // 设置了pthread_detach(s_loadingThread)，退出时会自动释放,  
    // 否则需要pthread_join()等待可结合的线程终止被释放它的栈寄存器资源.  
#endif  
    return 0;    
}    