#pragma once
/************************************************************************/
/* Some objects kind of objects should not be copied. This is particularly true
/* of objects involved in providing mutually exclusive access to something */
/************************************************************************/
class NonCopyable {
//! Restrict the copy constructor
NonCopyable(const NonCopyable&);
//! Restrict the assignment operator
const NonCopyable& operator=(const NonCopyable&);
protected:
//! Create a NonCopyable object
NonCopyable() { }
//! Destroy a NonCopyable object
~NonCopyable() { }
};
#pragma once
#include "NonCopyable.h"
#include <winbase.h>
//锁接口
class ILock
{
public:
virtual ~ILock() {}
virtual void Lock() = 0;
virtual void Unlock() = 0;
};
/************************************************************************/
/* CRITICAL_SECTION */
/************************************************************************/
class CriticalSectionLocker
: public ILock, private NonCopyable
{
public:
inline CriticalSectionLocker(void)
{
InitializeCriticalSectionAndSpinCount(&m_hCriticalSection, 4000); //增加旋转次数
}
inline virtual ~CriticalSectionLocker(void)
{
DeleteCriticalSection(&m_hCriticalSection);
}
inline virtual void Lock()
{
EnterCriticalSection(&m_hCriticalSection);
}
inline virtual void Unlock()
{
LeaveCriticalSection(&m_hCriticalSection);
}
private:
CRITICAL_SECTION m_hCriticalSection;
};
/************************************************************************/
/* Mutex */
/************************************************************************/
//互斥对象锁类
class MutexLocker
: public ILock , private NonCopyable
{
public:
MutexLocker()
{
m_mutex = ::CreateMutex(NULL, FALSE, NULL);
}
~MutexLocker()
{
if(m_mutex == NULL)
return;
::CloseHandle(m_mutex);
m_mutex=NULL;
}
inline virtual void Lock()
{
if(m_mutex == NULL)
return;
DWORD d = WaitForSingleObject(m_mutex, INFINITE);
}
inline virtual void Unlock()
{
if(m_mutex == NULL)
return;
::ReleaseMutex(m_mutex);
}
private:
HANDLE m_mutex;
};
/************************************************************************/
/* 信号量 */
/************************************************************************/
class SemaphoreLocker
: public ILock , private NonCopyable
{
private:
HANDLE m_handle;
public:
SemaphoreLocker(): m_handle(NULL)
{
m_handle = CreateSemaphore(NULL, 0, 1, NULL);
}
~SemaphoreLocker()
{
if(m_handle == NULL)
return;
int ret = CloseHandle(m_handle);
m_handle = NULL;
}
inline virtual void Lock()
{
if(m_handle == NULL)
return;
DWORD ret = WaitForSingleObject(m_handle, INFINITE);
//return (WAIT_OBJECT_0 == ret) ? true : false;
}
inline virtual void Unlock()
{
if(m_handle == NULL)
return;
ReleaseSemaphore(m_handle, 1, NULL);
}
};
/************************************************************************/
/* 自动锁 */
/************************************************************************/
template <typename LockTyp>
class AutoLock : private NonCopyable
{
LockTyp* m_pLock;
public:
AutoLock(LockTyp& locker)
{
m_pLock = &locker;
m_pLock->Lock();
}
AutoLock(LockTyp* locker)
{
m_pLock = locker;
m_pLock->Lock();
}
~AutoLock(void)
{
m_pLock->Unlock();
}
};
应用实例:
下面是对一个函数进行加锁
CString DoSomething( CString str )
{
AutoLock<CriticalSectionLocker> autoLock(_lockPageParse);
......
}