利用策略模式实现的线程同步

利用策略模式实现的线程同步

代码

头文件

#ifndef __MUTEX_DEMO__
#define __MUTEX_DEMO__

#include <windows.h>

//锁接口类
class ILock {
public:
virtual ~ILock(){}
virtual void Lock()   = 0;
virtual void Unlock()  = 0;
};

//互斥型的锁
class MutexLock:public ILock{
public:
MutexLock(){
m_mutex = ::CreateMutex(NULL,FALSE,NULL);
}
~MutexLock() {
::CloseHandle(m_mutex);
}

virtual void Lock() ;
virtual void Unlock() ;
private:
HANDLE m_mutex;
};

//临界区的锁
class CriticalLock:public ILock{
public:
CriticalLock(){
::InitializeCriticalSection(&m_critical);
}
~CriticalLock() {
::DeleteCriticalSection(&m_critical);
}

virtual void Lock()  ;
virtual void Unlock() ;
private:
CRITICAL_SECTION m_critical;
};

//同步
class Synchronize {
public:
Synchronize( ILock& m):m_lock(m){
m_lock.Lock();
}
~Synchronize(){
m_lock.Unlock();
}

private:
ILock& m_lock;
};

#endif

cpp文件

#include "Mutex_Demo.h"

void MutexLock::Lock()  {
DWORD d = WaitForSingleObject(m_mutex,INFINITE);
}

void MutexLock::Unlock()  {
::ReleaseMutex(m_mutex);
}

void CriticalLock::Lock()  {
EnterCriticalSection(&(m_critical));
}

void CriticalLock::Unlock()  {
LeaveCriticalSection((&m_critical));
}

>

//使用方法 1:
MutexLock mutex;

void func() {
Synchronize synch(mutex);
{
//TODO:..
//这个函数退出时，会调用synch的析构函数
//对mutex解锁
}
}
int main() {

return 1;
}

//使用方法 2:
CriticalLock critical;

void func() {
Synchronize synch(critical);
{
//TODO:..
//这个函数退出时，会调用synch的析构函数
//对mutex解锁
}
}
int main() {

return 1;
}

局部变量Synchronize synch在函数走完后，会调用析构函数解锁。所以，所以对于想偷懒的人来说，这是一个好的实现方式

设计模式

上面的代码使用了策略模式，具体的UML图如下