新浪围脖开放平台一"各种锁"

#ifndef __lo_LOCK_H__
#define __lo_LOCK_H__

#ifdef WIN32

#include <common/lo/lodefine.h>
#include <Windows.h>

DEFINE_NAMESPACE(locom)

class CloSemaphore
{
private:
 CloSemaphore& operator=(const CloSemaphore& r);
public:
 CloSemaphore(HANDLE* psem)
  :m_psem(psem)
 {
  *m_psem = ::CreateSemaphore(0,1,0XFFFF,0);
 }
 ~CloSemaphore()
 {
  ReleaseSemaphore(*m_psem,1,0);
  CloseHandle(*m_psem);
 }
 void Lock()
 {
  ::WaitForSingleObject(*m_psem,INFINITE);
 }
 void UnLock()
 {
  ReleaseSemaphore(*m_psem,1,0);
 }
private:
 HANDLE*   m_psem;
};

class CloCriticalSection
{
private:
 CRITICAL_SECTION *m_pSec;
public:
 CloCriticalSection( CRITICAL_SECTION *pSec )
  :m_pSec(pSec)
 {
  if ( m_pSec )
  {
   ::InitializeCriticalSection(m_pSec);
  }

 }

 ~CloCriticalSection()
 {
  if ( m_pSec )
  {
   ::DeleteCriticalSection(m_pSec);
  }
 }

 void Lock()
 {
  if ( m_pSec )
  {
   ::EnterCriticalSection(m_pSec);
  }

 }

 void UnLock()
 {
  if ( m_pSec )
  {
   ::LeaveCriticalSection(m_pSec);
  }
 }
};

class CloEvent
{
protected:
 HANDLE *m_pHandle;

public:
 CloEvent(HANDLE *pHandle,BOOL bManual)
  :m_pHandle(pHandle)
 {
  *m_pHandle = CreateEvent(NULL,bManual,FALSE,NULL);
 }

 ~CloEvent()
 {
  CloseHandle(*m_pHandle);
 }
};

class CloManualEvent : public CloEvent
{

private:
 HANDLE *m_pHandle;

public:
 CloManualEvent(HANDLE *pHandle)
  :CloEvent(pHandle,TRUE)
 {
 }

 void Lock()
 {
  WaitForSingleObject(*m_pHandle,INFINITE);
  ResetEvent(*m_pHandle);
 }

 void UnLock()
 {
  //使其有信号
  SetEvent(*m_pHandle);
 }
};

class CloAutoEvent : public CloEvent
{
public:
 CloAutoEvent(HANDLE *pHandle)
  :CloEvent(pHandle,FALSE)
 {

 }
 void Lock()
 {
  WaitForSingleObject(*m_pHandle,INFINITE);   
 }
 void UnLock()
 {
  //使其有信号
  SetEvent(*m_pHandle);
 }
};

class CloSignalEvent : public CloEvent
{
private:
 HANDLE pHandle;
public:

 CloSignalEvent()
  :CloEvent(&pHandle,FALSE)
 {

 }
 void Wait(int cms)
 {
  WaitForSingleObject(pHandle,cms);   
 }

 void WakeUp()
 {
  //使其有信号
  SetEvent(pHandle);
 }

 HANDLE Handle(void) const{ return pHandle;}
};

class CloMetuex
{
private:
 HANDLE *m_pHandle;

public:
 CloMetuex(HANDLE *pHandle)
  :m_pHandle(pHandle)
 {
  *m_pHandle = CreateMutex(NULL,FALSE,NULL);
 }

 ~CloMetuex()
 {
  CloseHandle(*m_pHandle);
 }

 void Lock()
 {
  WaitForSingleObject(*m_pHandle,INFINITE);
 }

 void UnLock()
 {
  ReleaseMutex(*m_pHandle);
 }
};

template<typename Type, typename LockPolicy>
class CloSmartLock
{
private:
 Type  m_Type;
 LockPolicy m_Policy;

public:
 CloSmartLock():m_Policy(&m_Type)
 {
 }

 void Lock()
 {
  m_Policy.Lock();
 }

 void UnLock()
 {
  m_Policy.UnLock();
 }
};

template<typename Type, typename LockPolicy>
class CloAutoLock
{
private:
 CloSmartLock<Type,LockPolicy> *m_pLock;
public:
 CloAutoLock(CloSmartLock<Type,LockPolicy> *pLock)
  :m_pLock(pLock)
 {
  m_pLock->Lock();
 }

 ~CloAutoLock()
 {
  m_pLock->UnLock();
 }
};

END_NAMESPACE(locom)

#endif // WIN32

#endif //__lo_LOCK_H__