c++封装win32多线程简介

/*
    线程函数如果声明在类中, 则需要静态函数.
    否则普通函数中将压入this参数 .

    所以在类中先声明一个静态函数,用于线程的启动.
    再写一个虚函数 run , 在线程中调用, 也可以用于子类的重写
*/
class ThreadObject{
public:
    ThreadObject() : m_thread(NULL), m_threadId(0){
    }
    void startThread(){
        m_thread = (HANDLE)_beginthreadex(NULL,
                                                                    0,
                                                                  ThreadObject::thread_func,  //静态函数
                                                                   (void*)this,                         //把this指针传入线程
                                                                    0,
                                                                    &m_threadId);
        if(m_thread)
            cout << "lauched , tid:" << m_threadId << endl;
        else
            cout << "error : " << GetLastError() << endl;
    }
    static unsigned  __stdcall thread_func(void *param){
        ThreadObject *pthis = (ThreadObject *)param; // this
        return pthis->run();
    }
    void waitThread(){
        if(m_thread){
            WaitForSingleObject(m_thread,-1);
            CloseHandle(m_thread);
         }
    }

    virtual DWORD run() = 0; //线程中真正执行的代码
    HANDLE m_thread;
    unsigned m_threadId;
};

CRITICAL_SECTION 的在c++中的使用:

//封装一个关键段 , enter 与 leave 在下面的例子中将被替换
class CS{
    CRITICAL_SECTION m_cs;
public:
    CS(){
        InitializeCriticalSectionAndSpinCount(&m_cs,4000);
    }
    ~CS(){
        DeleteCriticalSection(&m_cs);
    }
    void enter(){
        EnterCriticalSection(&m_cs);
    }
    void leave(){
        LeaveCriticalSection(&m_cs);
    }
};

//简化CS的使用  , 省的一直调用 enter , leave
class CSLock{
    CS * cs;
public:
    CSLock(CS * p) : cs(p){
        cs->enter();
    }
    ~CSLock(){
        cs->leave();
    }
};


//一个测试类
class Str{
public:
    Str():pData(0){}
    virtual ~Str(){
        CSLock s(&mcs);   //~CSLock将自动被调用
        if(pData)
            delete[] pData;
    }
    virtual void set(char * str){
        CSLock s(&mcs);
        if(pData)
            delete[] pData;
        pData = new char[strlen(str) + 1];
        strcpy(pData,str);
    }
    int len(){
        if(!pData)
            return 0;
        CSLock s(&mcs);
        int len = strlen(pData);
        return len;
    }
private:
    CS mcs;
    char *pData;
};

抽象上面的锁 , 用关键段作为例子:

// 一个锁的基类 ， 具体是CS, mutex, semphore , rwlock 无所谓
class LockableObject {
 public:
    LockableObject(){}
    virtual ~LockableObject(){}
    virtual void lock() = 0;
    virtual void unlock() = 0;
};

// 用CS实现
class SubClassCS : public LockableObject
{
public:
    SubClassCS()  {
        InitializeCriticalSectionAndSpinCount(&cs,4000);
    }
    virtual ~SubClassCS() {
        DeleteCriticalSection(&cs);
    }
    virtual void lock() {
        EnterCriticalSection(&cs);
    }
    virtual void unlock(){
        LeaveCriticalSection(&cs);
    }

private:
    CRITICAL_SECTION cs;
};

//以后使用这个锁对象即可. 
class UseLock {
public:
    UseLock(LockableObject * lock) : m_lock(lock){
        m_lock->lock();
    }
    ~UseLock(){
        m_lock->unlock();
    }
private:
    LockableObject * m_lock;
};

c++封装win32多线程简介

猜你喜欢