002.锁

以你之姓@ 2023-06-27 11:19 16阅读 0赞

直接代码

#pragma once;
    #include <windows.h>
    
    //
    // 互斥体
    class Mutex
    {
    	CRITICAL_SECTION m_cs;
    
    public:
    	Mutex();
    	~Mutex();
    	void Lock();
    	void Unlock();
    };
    
    //
    /// 临界区线程安全自动保护
    template<class _Mutex = Mutex>
    class ResGuard
    {
    	_Mutex& mMutex;
    public:
    	ResGuard(_Mutex& mtx) : mMutex(mtx)		{ mMutex.Lock(); }
    	~ResGuard()                             { mMutex.Unlock(); }
    };
    
    // 临界区自动锁
    struct AutoLock 
    {
    	inline AutoLock(LPCRITICAL_SECTION cs):_cs(cs){EnterCriticalSection(_cs);}
    	inline ~AutoLock(){LeaveCriticalSection(_cs);}
    	LPCRITICAL_SECTION _cs;
    };
    
    // 原子自动锁
    struct AtomLock 
    {
    	inline AtomLock(long volatile * v):_var(v){while(1 == InterlockedCompareExchange(_var, 1, 0)){Sleep(0);}}
    	inline ~AtomLock(){ *_var = 0;}
    	long volatile * _var;
    };
    
    // 互斥量自动锁
    struct AutoMutex
    {
    	inline AutoMutex(Mutex * m):_mutex(m){_mutex->Lock();}
    	inline ~AutoMutex(){_mutex->Unlock();}
    	Mutex * _mutex;
    };

#include "Lock.h"
    
    Mutex::Mutex()
    {
    	::InitializeCriticalSection(&m_cs);
    }
    
    Mutex::~Mutex()
    {
    	::DeleteCriticalSection(&m_cs);
    }
    
    void Mutex::Lock()
    {
    	::EnterCriticalSection(&m_cs);
    }
    
    void Mutex::Unlock()
    {
    	::LeaveCriticalSection(&m_cs);
    }

用到的部分函数说明

LONG InterlockedCompareExchange(
      LONG volatile* Destination,
      LONG Exchange,
      LONG Comparand
    );

Parameters

Destination

\[in, out\] A pointer to the destination value. The sign is ignored.

Exchange

\[in\] The exchange value. The sign is ignored.

Comparand

\[in\] The value to compare to Destination. The sign is ignored.

Return Value

The function returns the initial value of the Destination parameter.

Remarks