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

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

代码

头文件

#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图如下