跨平台lock

/*================================================================
*   Copyright (C) 2016 All rights reserved.
*   
*   filename：lock.h
*   author：Jiang Canjun
*   create date：2016-6-24
================================================================*/
#pragma  once
#ifdef WIN32
#include<Windows.h>
#else
#include <pthread.h>
#endif
//**********************************************************************

//处理读写锁的区别
//**********************************************************************
#ifdef WIN32
//适用于vista以及server 2008及以上系统
#define RWLOCK_VAR          SRWLOCK
#define INIT_RWLOCK_VAR(v)      InitializeSRWLock(&(v))
#define ENTER_READ_LOCK_VAR(v)  AcquireSRWLockShared(&(v))
#define LEAVE_READ_LOCK_VAR(v)  ReleaseSRWLockShared(&(v))
#define ENTER_WRITE_LOCK_VAR(v)  AcquireSRWLockExclusive(&(v))
#define LEAVE_WRITE_LOCK_VAR(v)  ReleaseSRWLockExclusive(&(v))
#define DELETE_RWLOCK_VAR(v)  
#else
#define RWLOCK_VAR				pthread_rwlock_t
#define INIT_RWLOCK_VAR(v)      pthread_rwlock_init(&(v), NULL)
#define ENTER_READ_LOCK_VAR(v)  pthread_rwlock_rdlock(&(v))
#define LEAVE_READ_LOCK_VAR(v)  pthread_rwlock_unlock(&(v))
#define ENTER_WRITE_LOCK_VAR(v)  pthread_rwlock_wrlock(&(v))
#define LEAVE_WRITE_LOCK_VAR(v)  pthread_rwlock_unlock(&(v))
#define DELETE_RWLOCK_VAR(v)      pthread_rwlock_destroy(&(v))
#endif
#ifdef WIN32
#define  thread_t  DWORD  
#define create_thread(id,attr,handler,arg)         CreateThread(NULL, 0, handler, arg, 0, &id)
#define exit_thread(v)                              ExitThread((v))  
#define thread_id()                             GetCurrentThreadId()
#else
#define  thread_t  pthread_t  
#define create_thread(id,attr,handler,arg)         pthread_create(&id, attr, handler, arg)
#define exit_thread(v)                             pthread_exit(&(v))
#define thread_id()                            pthread_self()
#endif
#ifdef WIN32
//适用于vista以及server 2008及以上系统
#define cond_t                   CONDITION_VARIABLE
#define init_cond(c)             InitializeConditionVariable(&c)
#define wait_cond(c,m)           SleepConditionVariableCS(&c, &m, 2*1000)
#define signal_cond(c)           WakeConditionVariable(&c)
#define broadcast_cond(c)        WakeAllConditionVariable(&c)
#define destroy_cond(c) 
#else
#define cond_t				    pthread_cond_t
#define init_cond(c)            pthread_cond_init(&(c), NULL)
#define wait_cond(c,m)          pthread_cond_wait(&(c),&(m))
#define signal_cond(c)          pthread_cond_signal(&(c))
#define broadcast_cond(c)       pthread_cond_broadcast(&(c))
#define destroy_cond(c)         pthread_cond_destroy(&(c))
#endif
#ifdef WIN32
#define mutex_t                 CRITICAL_SECTION
#define init_mutex(v)           InitializeCriticalSection(&(v))
#define lock_mutex(v)           EnterCriticalSection(&(v))
#define unlock_mutex(v)         LeaveCriticalSection(&(v))
#define try_lock_mutex(v)       TryEnterCriticalSection(&(v))
#define destroy_mutex(v)        DeleteCriticalSection(&(v))
#else
#define mutex_t                 pthread_mutex_t
#define init_mutex(v)           pthread_mutex_init(&(v),NULL)
#define lock_mutex(v)           pthread_mutex_lock(&(v))
#define unlock_mutex(v)         pthread_mutex_unlock(&(v))
#define try_lock_mutex(v)       !pthread_mutex_trylock(&(v))
#define destroy_mutex(v)        pthread_mutex_destroy(&(v))
#endif
class CLock
{
public:
    CLock();
    virtual ~CLock();
    void lock();
    void unlock();
	mutex_t getMutex() { return m_lock; }
    virtual bool try_lock();
private:
	mutex_t	m_lock;
};
class CRWLock
{
public:
    CRWLock();
    virtual ~CRWLock();
    void rlock();
    void wlock();
	void unrlock();
	void unwlock();
private:
	RWLOCK_VAR m_lock;
};

class CAutoRWLock
{
public:
    CAutoRWLock(CRWLock* pLock, bool bRLock = true);
    virtual ~CAutoRWLock();
private:
    CRWLock* m_pLock;
	bool m_bRLock;
};

class CAutoLock
{
public:
    CAutoLock(CLock* pLock);
    virtual ~CAutoLock();
private:
    CLock* m_pLock;
};

　　

#include "Lock.h"
CLock::CLock()
{
	init_mutex(m_lock);
}

CLock::~CLock()
{
	destroy_mutex(m_lock);
}

void CLock::lock()
{
	lock_mutex(m_lock);
}

void CLock::unlock()
{
	unlock_mutex(m_lock);
}

bool CLock::try_lock()
{
	return try_lock_mutex(m_lock);
}

CRWLock::CRWLock()
{
	INIT_RWLOCK_VAR(m_lock);
}

CRWLock::~CRWLock()
{
	DELETE_RWLOCK_VAR(m_lock);
}

void CRWLock::rlock()
{
	ENTER_READ_LOCK_VAR(m_lock);
}

void CRWLock::wlock()
{
	ENTER_WRITE_LOCK_VAR(m_lock);
}

void CRWLock::unrlock()
{
	LEAVE_READ_LOCK_VAR(m_lock);
}
void CRWLock::unwlock()
{
	LEAVE_WRITE_LOCK_VAR(m_lock);
}

CAutoRWLock::CAutoRWLock(CRWLock* pLock, bool bRLock)
{
	m_bRLock = bRLock;
    m_pLock = pLock;
    if(NULL != m_pLock)
    {
        if (bRLock) 
		{
            m_pLock->rlock();
        }
        else
        {
            m_pLock->wlock();
        }
    }
}

CAutoRWLock::~CAutoRWLock()
{
    if(NULL != m_pLock)
    {
		if (m_bRLock)
		{
			m_pLock->unrlock();
		}
		else
		{
			m_pLock->unwlock();
		}
    }
}

CAutoLock::CAutoLock(CLock* pLock)
{
    m_pLock = pLock;
    if(NULL != m_pLock)
        m_pLock->lock();
}

CAutoLock::~CAutoLock()
{
    if(NULL != m_pLock)
        m_pLock->unlock();
}