《ASCE1885的源码分析》の跨平台线程对象Thread封装基类

首先当然是先定义头文件Thread.h咯，如下：
#ifndef _THREAD_H
#define _THREAD_H
 
#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif
 
#ifdef _WIN32
typedef unsigned threadfunc_t;
typedef void* threadparam_t;
#define STDPREFIX __stdcall
#else
typedef void* threadfunc_t;
typedef void* threadparam_t;
#define STDPREFIX
#endif
 
//线程的基类
class Thread
{
public:
    Thread(bool release=true);
    virtual ~Thread();
   
    static threadfunc_t STDPREFIX StartThread(threadparam_t);
   
    virtual void Run()=0;  //纯虚函数，由派生类实现
   
#ifdef _WIN32
    HANDLE GetThread(){return m_thread;}
    unsigned GetThreadId(){return m_dwThreadId;}
#else
    pthread_t GetThread(){return m_thread;}
#endif
 
    bool IsRunning();
    void SetRunning(bool x);
    bool IsReleased();
    void SetRelease(bool x);
    bool DeleteOnExit();
    void SetDeleteOnExit(bool x=true);
    bool IsDestructor();
   
protected:
#ifdef _WIN32
    HANDLE m_thread;
    unsigned m_dwThreadId;
#else
    pthread_t m_thread;
#endif
 
private:
    Thread(const Thread&){}
    Thread& operator=(const Thread&){return *this;}
    bool m_running;
    bool m_release;
    bool m_b_delete_on_exit;
    bool m_b_destructor;
};
 
#endif
 
接着是实现文件Thread.cpp，由于代码比较简单，就不多解释了，直接看代码里的注释就行了：
#include <stdio.h>
#ifdef _WIN32
#include <process.h>
#else
#include <unistd.h>
#endif
 
#include "Thread.h"
 
Thread::Thread(bool release)
    :m_thread(0),
    m_running(true),
    m_release(false),
    m_b_delete_on_exit(false),
    m_b_destructor(false)
{
#ifdef _WIN32
    m_thread = (HANDLE)_beginthreadex(NULL, 0, &StartThread,
                                            this, 0, &m_dwThreadId);   
#else
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    if(pthread_create(&m_thread, &attr, StartThread, this) == 1)
    {
        perror("Thread:create failed");
        SetRunning(false);
    }
#endif
    m_release = release;
}           
 
Thread::~Thread()
{
    m_b_destructor = true;
    if(m_running)
    {
        SetRelease(true);
        SetRunning(false);
#ifdef _WIN32
        Sleep(1000);
#else
        sleep(1);
#endif           
    }
#ifdef _WIN32
    if(m_thread)
        ::CloseHandle(m_thread);
#endif                  
}
 
//线程函数
threadfunc_t STDPREFIX Thread::StartThread(threadparam_t zz)
{
    Thread *p = (Thread*)zz;
    while(p->m_running && !p->m_release)
    {
#ifdef _WIN32
        Sleep(1000);
#else
        sleep(1);
#endif                  
    }
   
    if(p->m_running)
    {
        p->Run();              
    }
    p->SetRunning(false); //Run()运行完了，或根本没运行
    if(p->DeleteOnExit() && !p->IsDestructor())
    {
        delete p;                    
    }
#ifdef _WIN32
    _endthreadex(0);
#endif
    return (threadfunc_t)NULL;
}
 
bool Thread::IsRunning()
{
    return m_running;    
}
 
void Thread::SetRunning(bool x)
{
    m_running = x;    
}
 
bool Thread::IsReleased()
{
    return m_release;    
}
 
void Thread::SetRelease(bool x)
{
    m_release = x;    
}
 
//退出时是否释放线程对象Thread*
bool Thread::DeleteOnExit()
{
    return m_b_delete_on_exit;    
}
 
void Thread::SetDeleteOnExit(bool x)
{
    m_b_delete_on_exit = x;    
}
 
//是否已经调用了析构函数
bool Thread::IsDestructor()
{
   return m_b_destructor;    
}