抄windows核心编程中很方便的一种加琐方式

使用临界区的一个类

#include <Windows.h>

class CResLock
{
public:
 CResLock(void);
 ~CResLock(void);
public:
 void Lock(void);
 void UnLock(void);
 BOOL IsLocked(void);

private:
 CRITICAL_SECTION m_cs;
 int m_nLockNum;
};

 

CResLock::CResLock(void)
{
 InitializeCriticalSection(&m_cs);
 m_nLockNum = 0;
}

CResLock::~CResLock(void)
{
 DeleteCriticalSection(&m_cs);
}

void CResLock::Lock()
{
 EnterCriticalSection(&m_cs);
 m_nLockNum++;
}

void CResLock::UnLock()
{
 LeaveCriticalSection(&m_cs);
 m_nLockNum++;
}

BOOL CResLock::IsLocked()
{
 return (0 == m_nLockNum)?FALSE:TRUE;
}

 

通过构造函数和释构函数枷锁和解锁的类

class CLocker
{
public:
 CLocker(CResLock &rsLock);
 ~CLocker(void);

private:
 CResLock *m_pRsLock;
};

 

CLocker::CLocker(CResLock &rsLock)
{
 m_pRsLock = &rsLock;
 m_pRsLock->Lock();
}

CLocker::~CLocker(void)
{
 m_pRsLock->UnLock();
}

 

测试代码

#include "ResGuard.h"
#include "Locker.h"
#include <process.h>

unsigned __stdcall testLocker(void *prsLock);

int _tmain(int argc, _TCHAR* argv[])
{
 CResLock rsLock;
 HANDLE   hThread[3] = {NULL};

 for (int i = 0; i < 3; i++)
 {
  hThread[i] = (HANDLE) _beginthreadex(NULL, 0, testLocker, &rsLock, NULL, NULL);
 }
 
 WaitForMultipleObjects(3, hThread, TRUE, -1);
 for (int i = 0; i < 3; i++)
 {
  CloseHandle(hThread[i]);
  hThread[i] = NULL;
 }

 printf("Game over /r/n");

 getchar();

 return 0;
}

static int nNumber = 0;
unsigned __stdcall testLocker(void *prsLock)
{
 if (NULL == prsLock)
  return -1;
 
 int nThreadNum = nNumber;
 nNumber++;
 CResLock *pLock = (CResLock *) prsLock;

 for (int i = 0; i < 3; i++)
 {
  CLocker(*pLock);  //这里只需要这样就达到了枷锁的目的了, 不怕忘记释放
  printf("the thread number is %d, loop number is %d /r/n", nThreadNum, i);
  Sleep(1000);
 }

 return 0;
}