使用巨集區分win和linux下的鎖的實現。

標頭檔案

RWLock.h

//////////////////////////////////////////////////////////////////////////
//讀寫鎖
//////////////////////////////////////////////////////////////////////////
#ifndef  _RWMETUX_H_
#define  _RWMETUX_H_
//////////////////////////////////////////////////////////////////////////
#ifndef  WIN32
  #include <pthread.h>
#endif
//////////////////////////////////////////////////////////////////////////
// 多證書鏈讀寫鎖類
#ifdef  WIN32
typedef struct _RWLock
{
	HANDLE hMutex;    
	HANDLE hDataLock;
	int nReaderCount;
} RWLock;
#endif
class  CRWLock
{
public:
	CRWLock();
	~CRWLock();
	BOOL  AcquireReadLock(void);    //請求讀操作鎖,請求不成功則阻塞
	BOOL  ReleaseReadLock(void);    //釋放讀操作鎖
	BOOL  AcquireWriteLock(void);   //請求寫操作鎖,請求不成功則阻塞
	BOOL  ReleaseWriteLock(void);   //釋放寫操作鎖
private:
	BOOL  MyWaitForSingleObject(HANDLE hObject);
	BOOL  InitRWLock();
	BOOL  DestroyRWLock();
#ifdef  WIN32
	RWLock m_RWLock;   //讀寫鎖
#else
	pthread_rwlock_t m_RWLock;
#endif
};
#endif   //_RWMETUX_H_
 

RWLock.cpp

//////////////////////////////////////////////////////////////////////////
//讀寫鎖
//////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "RWLock.h"
//////////////////////////////////////////////////////////////////////////
#ifndef FALSE 
#define FALSE 0
#endif

#ifndef TRUE
#define TRUE 1
#endif

//完成讀寫鎖初始化
CRWLock::CRWLock()
{
	InitRWLock();
}
CRWLock::~CRWLock()
{
	DestroyRWLock();
}

BOOL  CRWLock::MyWaitForSingleObject(HANDLE hObject)
{
#ifdef WIN32
	DWORD result;
	result = WaitForSingleObject(hObject, INFINITE);
	return (result == WAIT_OBJECT_0);
#endif
}


BOOL  CRWLock::InitRWLock()
{
#ifdef WIN32
	m_RWLock.nReaderCount = 0;
	m_RWLock.hDataLock = CreateSemaphore(NULL, 1, 1, NULL);
	if (m_RWLock.hDataLock == NULL)
	{
		return FALSE;
	}
	m_RWLock.hMutex = CreateMutex(NULL, FALSE, NULL);
	if (m_RWLock.hMutex == NULL)
	{
		CloseHandle(m_RWLock.hDataLock);
		return FALSE;
	}
	return TRUE;
#else
	pthread_rwlock_init(&m_RWLock, NULL);
	return TRUE;
#endif
}


BOOL  CRWLock::DestroyRWLock()
{
#ifdef WIN32
	DWORD result = WaitForSingleObject(m_RWLock.hDataLock, INFINITE);
	if (result != WAIT_OBJECT_0)
	{
		return FALSE;
	}
	CloseHandle(m_RWLock.hMutex);
	CloseHandle(m_RWLock.hDataLock);
	return TRUE;
#else
	pthread_rwlock_destroy(&m_RWLock);
	return TRUE;
#endif
}


BOOL CRWLock::AcquireReadLock()
{
BOOL result = TRUE;
#ifdef WIN32
	if (MyWaitForSingleObject(m_RWLock.hMutex) == FALSE)
	{
		return FALSE;
	}

	m_RWLock.nReaderCount ++;
	if(m_RWLock.nReaderCount == 1)
	{
		result = MyWaitForSingleObject(m_RWLock.hDataLock);
	}
	ReleaseMutex(m_RWLock.hMutex);
	return result;
#else
	pthread_rwlock_rdlock(&m_RWLock);
	return result;
#endif
}


BOOL CRWLock::ReleaseReadLock()
{
	int result = TRUE;
#ifdef WIN32
	LONG lPrevCount;
	if (MyWaitForSingleObject(m_RWLock.hMutex) == FALSE)
	{
		return FALSE;
	}
	--m_RWLock.nReaderCount;
	if (m_RWLock.nReaderCount == 0)
	{
		result = ReleaseSemaphore(m_RWLock.hDataLock, 1, &lPrevCount);
	}
	ReleaseMutex(m_RWLock.hMutex);
	return result;
#else
		return pthread_rwlock_unlock(&m_RWLock);
#endif
}


BOOL CRWLock::AcquireWriteLock()
{
#ifdef WIN32
	return MyWaitForSingleObject(m_RWLock.hDataLock);
#else
	return pthread_rwlock_wrlock(&m_RWLock);
#endif
}

BOOL CRWLock::ReleaseWriteLock()
{
#ifdef WIN32
	int result = TRUE;
	LONG lPrevCount;
	result = ReleaseSemaphore(m_RWLock.hDataLock, 1, &lPrevCount);
	if (lPrevCount != 0)
	{
	  return FALSE;
	}
	return result;
#else
	return  pthread_rwlock_unlock(&m_RWLock);
#endif
}