文章目录

• • 一、锁
  • 二、自动锁
  • • 1、普通锁实现
    • 2、自动锁实现
    • 3、自动锁使用

一、锁

• 锁 是 多线程编程 中一个很常用的概念，这里不多加介绍其原理，有兴趣可以参考 临界区 进行更多的了解；
• 锁 一般会提供三个接口：加锁（Lock）、解锁（UnLock）、尝试加锁（TryLock）；
• 本文将利用 C++ 的 构造函数 和 析构函数，把 加锁 和 解锁 在一行代码中实现；

二、自动锁

1、普通锁实现

• 这里利用 CRITICAL_SECTION 相关的接口实现了一系列普通锁的接口封装；

class ILock
{
public:
    ILock(){}
    virtual ~ILock(){}
    virtual void Lock(void) = 0;
    virtual bool TryLock(void) = 0;
    virtual void UnLock(void) = 0;
};

class NLock : public ILock
{
public:
    NLock (){
        InitializeCriticalSection(&m_kSection);
    }
    virtual ~NLock (){
        DeleteCriticalSection(&m_kSection);
    }
    virtual void Lock(void){
        EnterCriticalSection(&m_kSection);
    }
    virtual bool TryLock(void){
        return (TryEnterCriticalSection(&m_kSection) > 0);
    }
    virtual void UnLock(void){
        LeaveCriticalSection(&m_kSection);
    }
protected:
    CRITICAL_SECTION m_kSection;
};

2、自动锁实现

• 1）构造函数：接收传入的 锁指针，并且存成成员变量；
• 2）析构函数：对成员变量的锁执行解锁操作；

class AutoLock   // 注意：这里不继承 ILock
{
public:
    AutoLock(ILock *pkLock) {
        m_pkLock = pkLock;
        m_pkLock->Lock();
    }
    ~AutoLock() {
        m_pkLock->UnLock();
    }
protected:
    ILock*	m_pkLock;
};

3、自动锁使用

int main() {
	NLock m_kLock;
	{
		AutoLock kAutoLock(&m_kLock);   // 1）构造函数中执行 m_kLock 的加锁
		// 执行对应加锁后的操作
	}
	// 2）退出 kAutoLock 作用域，自动调用析构，执行 m_kLock 解锁
	return 0;
}

• 1）构造函数中执行 m_kLock 的加锁；
• 2）退出 kAutoLock 作用域，自动调用析构，执行 m_kLock 解锁；