/*
    執行緒函式如果宣告在類中, 則需要靜態函式.
    否則普通函式中將壓入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;
};