boost中的mutex与lock

基本用法:

HANDLE g_mutex = NULL; 
void test() 
{ 
    ::WaitForSingleObject(g_mutex, INFINITE); 
    //do something... 
    ReleaseMutex(g_mutex); 
} 

封装:

class MyMutex 
{ 
public: 
    MyMutex() 
        :m_hMutex(NULL) 
    { 
    } 
    MyMutex(wchar_t* pMutexName) 
        :m_hMutex(NULL) 
    { 
        createMutex(pMutexName); 
    } 
    virtual ~MyMutex() 
    { 
       destroyMutex(); 
    } 
    bool lock() 
    { 
        return m_hMutex ? (::WaitForSingleObject(m_hMutex,INFINITE) == WAIT_OBJECT_0) : false; 
    } 
    void unlock() 
    { 
        ReleaseMutex(m_hMutex); 
    } 
    bool createMutex(wchar_t* pMutexName) 
    { 
        if (m_hMutex) 
        { 
            return true; 
        } 
m_hMutex = ::CreateMutex(NULL, FALSE, pMutexName); 
        return m_hMutex != NULL; 
    } 
    void destroyMutex() 
    { 
        CloseHandle(m_hMutex); 
m_hMutex = NULL; 
    } 
    bool openMutex(wchar_t* pMutexName) 
    { 
        if (m_hMutex) 
        { 
            return true; 
        } 
m_hMutex = ::OpenMutex(SYNCHRONIZE, FALSE, pMutexName); 
        return m_hMutex != NULL; 
    } 
private: 
    HANDLE m_hMutex; 
}; 

用法:

void test1() 
{ 
    MyMutex mutex; 
    mutex.createMutex(L"mutex_test_name1"); 
    if (mutex.lock()) 
    { 
        //do something... 
        mutex.unlock(); 
    } 
} 

帮助类:

class MyMutexLockGuard 
{ 
public: 
    MyMutexLockGuard(MyMutex* pMutex) 
    { 
m_pMutex = pMutex; 
        if (m_pMutex) 
        { 
            m_pMutex->lock(); 
        } 
    } 
    virtual ~MyMutexLockGuard() 
    { 
        if (m_pMutex) 
        { 
            m_pMutex->unlock(); 
        } 
    } 
private: 
    MyMutex* m_pMutex; 
}; 

void test2() 
{ 
    MyMutex mutex(L"mutex_test_name2"); 
    {//scope 1 
        MyMutexLockGuard lock(&mutex); 
        //do something... 
    } 
    //out of the scope 1, the mutex has been unlocked 
} 

当离开作用域1时，lock对象被析构，自动调用mutex.unlock函数释放锁。是不是很爽...

需要注意的是CreateMutex和OpenMutex这两个windows api，CreateMutex的第二个参数bInitialOwner最好设为false。设为true时代表创建这个mutex的线程是直接获取这个mutex,相当于创建这个mutex的过程中调用了waitforsingleobject,因此即使后来lock和unlock配对调用,最后先启动的这个线程还是没有释放这个mutex，必须手动再调用一次unlock才行。因此设为false更稳妥些。OpenMutex的第一个参数安全属性最好设为SYNCHRONIZE ，win7和vista下不要用ALL_ACCESS，有可能失败。第二参数表示进程创建出的子进程是否可以直接继承该mutex。

上面的是mutex的基本用法，更强大的是boost中对于mutex和lock的实现。

boost中的mutex貌似有6种或者更多，我用过的有3中boost::mutex、boost::shared_mutex、boost::recursive_mutex，貌似还有boost::try_mutex、boost::time_mutex，不过没用过。

boost::mutex是最基础的锁，有lock和unlock方法，可以认为是互持锁。boost::shared_mutex是共享锁，有lock、unlock方法以及shared_lock、shared_unlock方法。boost::recursive_mutex是重入锁或者称为递归锁，这个最后再说。

boost::shared_mutex可以用来实现读写锁。多线程中的一个经典问题是一写多读，即当有线程发生写操作时，所有其他线程的读操作暂停，其他时刻，允许多个线程同时读操作。使用boost::shared_mutex构造读写锁时需要使用到boost中的lock帮助类系列（作用类似上面我写的MyMutexLockGuard）。boost::shared_lock<T>和boost::unique_lock<T>，从字面上看，shared_lock是共享的，unique_lock是独占的，shared_lock<T>只允许T是shared_mutex，而unique_lock<T>对T没有限制，如果T是shared_mutex，则在执行加锁和解锁时会调用shared_lock和shared_unlock方法，否则，则执行一般的lock和unlock方法。

实现读写锁：

typedef boost::unique_lock<boost::shared_mutex> ReadLock; 
     typdef boost::shared_lock<boost::shared_mutex> WriteLock; 
     boost::shared_mutex  read_write_mutex; 
     void _ReadThreadFunc() 
     { 
    ReadLock read_lock(read_write_mutex); 
    //read data... 
     } 
     void _WriteThreadFunc() 
     {   
    WriteLock write_lock(read_write_mutex); 
    //write data... 
     } 

 使用boost::unique_lock和boost::mutex则可以实现最基本的独占时互斥

boost::unique<boost::mutex> MyLock 
     boost::mutex myMutex; 
     void func() 
    { 
         MyLock lock(myMutex); 
         // do something... 
    } 

lock_guard:

boost::mutex g_mutex; 
void test4() 
{ 
    boost::lock_guard<boost::mutex> lock(g_mutex); 
    //do something... 
} 
void test3() 
{ 
    boost::lock_guard<boost::mutex> lock(g_mutex); 
    test4(); 
    //do something... 
} 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    test3(); 
    return 0; 
} 

点击打开链接