c++编程---锁

一 互斥锁

备注： 互斥锁详细应用请参考下面博客：
https://blog.csdn.net/WizardtoH/article/details/81452066

1 互斥量

(1) std::mutex

描述:最基本的Mutex

(2) std::recursive_mutex

名称：递归Mutex
描述：递归mutex类，能多次锁定而不死锁

(3) std::time_mutex

名称：定时Mutex
描述：定时mutex类，可以为了锁定而等待一定的时间

(4) std::recursive_timed_mutex

名称：定时递归Mutex

2 Lock 函数

(1) std::lock_guard

描述:与 Mutex RAII 相关，方便线程对互斥量上锁。

(2) std::unique_lock

描述：与 Mutex RAII 相关，方便线程对互斥量上锁，但提供了更好的上锁和解锁控制

(3) std::try_lock std::lock

描述： std::try_lock：尝试同时对多个互斥量上锁。
描述： std::lock：可以同时对多个互斥量上锁。

(4) std::call_once

描述： 如果多个线程需要同时调用某个函数，call_once可以保证多个线程对该函数只调用一次。

二 读写锁

#ifdef _MSC_VER
#include <process.h>
#include <windows.h>

class RWLock {
 public:
    RWLock() { InitializeSRWLock(&_rwlock); }
    ~RWLock() { }
    void rdlock()   { AcquireSRWLockShared(&_rwlock); }
    void rdunlock() { ReleaseSRWLockShared(&_rwlock); }
    void wrlock()   { AcquireSRWLockExclusive(&_rwlock); }
    void wrunlock() { ReleaseSRWLockExclusive(&_rwlock); }
 private:
    SRWLOCK _rwlock;
};
#else
#include <pthread.h>

class RWLock{
 public:
    RWLock() { pthread_rwlock_init(&_rwlock, NULL); }
    ~RWLock() { pthread_rwlock_destroy(&_rwlock); }
    void rdlock()   { pthread_rwlock_rdlock(&_rwlock); }
    void rdunlock() { pthread_rwlock_unlock(&_rwlock); }
    void wrlock()   { pthread_rwlock_wrlock(&_rwlock); }
    void wrunlock() { pthread_rwlock_unlock(&_rwlock); }
 private:
    pthread_rwlock_t _rwlock;
};
#endif

三 其他

备注： 如果未采用c++11 可以用下面跨平台互斥锁

#ifdef _MSC_VER
#include <windows.h>
#else
#include <pthread.h>
#endif //_MSC_VER
class IMyLock
{
public:
 virtual ~IMyLock() {}
 virtual void Lock() = 0;
 virtual void Unlock() = 0;
};
class XLock
{
public:
    XLock(IMyLock* plock)
 {
        m_lock = plock;
  m_lock->Lock();
 }
 ~XLock()
 {
  m_lock->Unlock();
  m_lock = NULL;
 }
private:
    IMyLock* m_lock;
};
#ifdef _MSC_VER
class XMutex : public IMyLock
{
public:
 XMutex()
 {
  m_mutex = ::CreateMutex(NULL, FALSE, NULL); 
 }
 ~XMutex()
 {
  ::CloseHandle(m_mutex); 
 }
 virtual void Lock()
 {
  WaitForSingleObject(m_mutex, INFINITE); 
 }
 virtual void Unlock()
 {
  ::ReleaseMutex(m_mutex);
 }
private:
 HANDLE m_mutex;
};
#else 
class XMutex : public IMyLock
{
public:
 XMutex()
 {
  pthread_mutexattr_t mattr;
  pthread_mutexattr_init( &mattr );
  pthread_mutex_init( &m_mutex, &mattr );
 }
 ~XMutex()
 {
  pthread_mutex_destroy( &m_mutex );
 }
 virtual void Lock()
 {
  pthread_mutex_lock( &m_mutex );
 }
 virtual void Unlock()
 {
  pthread_mutex_unlock( &m_mutex );
 }
private:
 pthread_mutex_t m_mutex;
};
#endif //#ifdef _MSC_VER