临界区(Critical Section)的封装和使用示例

Myth丶恋晨 2022-04-11 05:56 223阅读 0赞

转自  
\[url\]http://www.cnblogs.com/sixbeauty/p/3951406.html\[/url\]  
  
这个做法其实是抄我老大的。服务器中，多线程经常需要使用临界区，为了简化代码的使用，把临界区封装为 CThreadLockHandle 类，通过封装，使用临界区资源每次只需要一行代码，而且只要确定对象的生存周期，就能完成对临界区资源的自动释放：  
  
头文件:

//thread_lock.h
    #ifndef THREAD_LOCK_HEAD_FILE
    #define THREAD_LOCK_HEAD_FILE
    #include<windows.h>
    
    
    //临界区同步类
    class CThreadLock
    {
       
        //变量定义
    private:
        CRITICAL_SECTION                m_csLock;            //临界区变量
    
        //函数定义
    public:
        //构造函数
        inline CThreadLock() {    ::InitializeCriticalSection(&m_csLock);    };
        //析构函数
        inline ~CThreadLock() {    ::DeleteCriticalSection(&m_csLock);    };
    
        //功能函数
    public:
        //锁定函数
        inline void Lock() {    ::EnterCriticalSection(&m_csLock); };
        //解锁函数
        inline void UnLock() {    ::LeaveCriticalSection(&m_csLock); };
    };
    
    
    
    //安全同步锁定句柄
    class CThreadLockHandle
    {
       
        //变量定义
    private:
        int                                m_nLockCount;        //锁定计数
        CThreadLock                        *m_pThreadLock;        //锁定对象
    
        //函数定义
    public:
        //构造函数
        CThreadLockHandle(CThreadLock *pThreadLock, bool bAutoLock=true);
        //析构函数
        virtual ~CThreadLockHandle();
    
        //功能函数
    public:
        //锁定函数
        void Lock();
        //解锁函数
        void UnLock();
        //火枪锁定次数
        int inline GetLockCount() {    return m_nLockCount; };
    };
    
    #endif

源文件：

//thread_lock.cpp   programed by sany
    //2014.9.2
    //callme:sanyue9394@163.com
    
    
    #include "thread_lock.h"
    #include<assert.h>
    
    
    //安全同步锁定句柄
    //构造函数
    CThreadLockHandle::CThreadLockHandle(CThreadLock *pThreadLock, bool bAutoLock)
    {
       
        assert(pThreadLock!=NULL);
        m_nLockCount=0;
        m_pThreadLock=pThreadLock;
        if(bAutoLock)    Lock();
        return;
    }
    //析构函数
    CThreadLockHandle::~CThreadLockHandle()
    {
       
        while(m_nLockCount>0) UnLock();                                //生存周期结束自动解锁
    }
    
    //锁定函数
    void CThreadLockHandle::Lock()
    {
       
        //校验状态
        assert(m_nLockCount>=0);
        assert(m_pThreadLock!=NULL);
    
        //锁定对象
        m_nLockCount++;
        m_pThreadLock->Lock();
    }
    
    //解锁函数
    void CThreadLockHandle::UnLock()
    {
       
        //校验状态
        assert(m_nLockCount>0);
        assert(m_pThreadLock!=NULL);
    
        //解除状态
        m_nLockCount--;
        m_pThreadLock->UnLock();
    }

经过这个类的封装，使用临界区实现线程同步只需要2步：  
  
1.初始化一个全局的 CThreadLock 对象，为后面调用做准备。  
  
2.每当需要使用临界区时，在作用域中声明一个局部变量：CThreadLockHandle ，当其生存周期结束时，将自动释放临界区资源  
  
  
使用例子：

#include<stdio.h>
    #include<windows.h>
    #include <process.h> 
    #include"thread_lock.h"
    
    const int aSize=10;
    char szArr[aSize+1]={};
    
    CThreadLock                        threadLock;                            //声明CThreadLock类型的全局变量
    
    unsigned _stdcall threadFunc1(void*)
    {
       
        CThreadLockHandle lockHandle(&threadLock);                        //需要使用临界区是，声明一个CThreadLockHandle类型的变量，其生存周期结束自动解锁
        for(int s=0;s<aSize;s++)
        {
       
            szArr[s]='a';
            Sleep(1);
        }
        return 0;
    }
    
    unsigned _stdcall threadFunc2(void*)
    {
       
        CThreadLockHandle lockHandle(&threadLock);                        //需要使用临界区是，声明一个CThreadLockHandle类型的变量，其生存周期结束自动解锁
        for(int s=0;s<aSize;s++)
        {
       
            szArr[aSize-1-s]='b';
            Sleep(1);
        }
        return 0;
    }
    
    int main()
    {
       
        memset(szArr,0,sizeof(szArr));
        HANDLE handle1=(HANDLE)_beginthreadex(NULL,0,threadFunc1,NULL,0,0);
        HANDLE handle2=(HANDLE)_beginthreadex(NULL,0,threadFunc2,NULL,0,0);
    
        WaitForSingleObject(handle1,INFINITE);
        WaitForSingleObject(handle2,INFINITE);
    
        printf("%s\n",szArr);
        CloseHandle(handle1);
        CloseHandle(handle2);
    
        return 0;
    }

如果在类中调用，把CThreadLock 对象声明为私有或保护成员即可：

class threadtest
    {
       
    protected:
        static CThreadLock                        m_ThreadLock;                //线程锁
    
    public:
        static unsigned _stdcall threadFunction(void* pThreadData);
    };
    unsigned _stdcall threadtest::threadFunction(void* pThreadData)
    {
       
        CThreadLockHandle lockHandle(&m_ThreadLock);                //生存周期结束自动解锁
        //doSomething
        return 0;
    }

附：http://www.cnblogs.com/userinterface/archive/2005/04/27/146137.html 不错的线程同步文章