跨平台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
#include <atomic>
//**********************************************************************

//处理读写锁的区别
//**********************************************************************
#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
class CLock
{
public:
    CLock();
    virtual ~CLock();
    void lock();
    void unlock();
#ifdef WIN32
	CRITICAL_SECTION&
#else
	pthread_mutex_t&
#endif
	 getMutex() { return m_lock; }
    virtual bool try_lock();
private:
#ifdef WIN32
	CRITICAL_SECTION 
#else
    pthread_mutex_t 
#endif
		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;
};
class Atomic
{
public:
	Atomic();
	~Atomic();
	void lock();
	bool try_lock();
	void unlock();
private:
	std::atomic_flag m_lock;
};

　　实现文件：

#include "Lock.h"
CLock::CLock()
{
#ifdef WIN32
	InitializeCriticalSection(&m_lock);
#else
	pthread_mutex_init(&m_lock,NULL);
#endif
}

CLock::~CLock()
{
#ifdef WIN32
	DeleteCriticalSection(&m_lock);
#else
	pthread_mutex_destroy(&m_lock);
#endif
}

void CLock::lock()
{
#ifdef WIN32
	EnterCriticalSection(&m_lock);
#else
	pthread_mutex_lock(&m_lock);
#endif
}

void CLock::unlock()
{
#ifdef WIN32
	LeaveCriticalSection(&m_lock);
#else
	pthread_mutex_unlock(&m_lock);
#endif
}

bool CLock::try_lock()
{
#ifdef WIN32
	return TryEnterCriticalSection(&m_lock) != 0;
#else
	return pthread_mutex_trylock(&m_lock) == 0;
#endif
}

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();
}

Atomic::Atomic()
{
	m_lock.clear();
}
Atomic::~Atomic()
{

}
void Atomic::lock()
{
	while (m_lock.test_and_set());
}
bool Atomic::try_lock()
{
	return m_lock.test_and_set();
}
void Atomic::unlock()
{
	m_lock.clear();
}