多线程同步锁

#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);

    ......
}