一个Windows C++的线程类实现

Thread.h

 

#ifndef __THREAD_H__
#define __THREAD_H__

#include <string>

#include   <windows.h>
#include   <process.h>

class Runnable
{
public:
    virtual ~Runnable() {};
    virtual void Run() = 0;
};

class CThread : public Runnable
{
private:
    explicit CThread(const CThread & rhs);

public:
    CThread();
    CThread(Runnable * pRunnable);
    CThread(const char * ThreadName, Runnable * pRunnable = NULL);
    CThread(std::string ThreadName, Runnable * pRunnable = NULL);
    ~CThread(void);

    /**
      开始运行线程
      @arg bSuspend 开始运行时是否挂起
    **/
    bool Start(bool bSuspend = false);

    /**
      运行的线程函数，可以使用派生类重写此函数
    **/
    virtual void Run();

    /**
      当前执行此函数线程等待线程结束
      @arg timeout 等待超时时间，如果为负数，等待无限时长
    **/
    void Join(int timeout = -1);
    /**
      恢复挂起的线程
    **/
    void Resume();
    /**
      挂起线程
    **/
    void Suspend();
    /**
      终止线程的执行
    **/
    bool Terminate(unsigned long ExitCode);

    unsigned int GetThreadID();
    std::string GetThreadName();
    void SetThreadName(std::string ThreadName);
    void SetThreadName(const char * ThreadName);

private:
    static unsigned int WINAPI StaticThreadFunc(void * arg);

private:
    HANDLE m_handle;
    Runnable * const m_pRunnable;
    unsigned int m_ThreadID;
    std::string m_ThreadName;
    volatile bool m_bRun;
};

#endif

 

Thread.cpp

 

#include "Thread.h"

CThread::CThread(void) :
m_pRunnable(NULL),
m_bRun(false)
{
}

CThread::~CThread(void)
{
}

CThread::CThread(Runnable * pRunnable) :
m_ThreadName(""),
m_pRunnable(pRunnable),
m_bRun(false)
{
}

CThread::CThread(const char * ThreadName, Runnable * pRunnable) :
m_ThreadName(ThreadName),
m_pRunnable(pRunnable),
m_bRun(false)
{
}

CThread::CThread(std::string ThreadName, Runnable * pRunnable) :
m_ThreadName(ThreadName),
m_pRunnable(pRunnable),
m_bRun(false)
{
}

bool CThread::Start(bool bSuspend)
{
    if(m_bRun)
    {
        return true;
    }
    if(bSuspend)
    {
        m_handle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadFunc, this, CREATE_SUSPENDED, &m_ThreadID);
    }
    else
    {
        m_handle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadFunc, this, 0, &m_ThreadID);
    }
    m_bRun = (NULL != m_handle);
    return m_bRun;
}

void CThread::Run()
{
    if(!m_bRun)
    {
        return;
    }
    if(NULL != m_pRunnable)
    {
        m_pRunnable->Run();
    }
    m_bRun = false;
}

void CThread::Join(int timeout)
{
    if(NULL == m_handle || !m_bRun)
    {
        return;
    }
    if(timeout <= 0)
    {
        timeout = INFINITE;
    }
    ::WaitForSingleObject(m_handle, timeout);
}

void CThread::Resume()
{
    if(NULL == m_handle || !m_bRun)
    {
        return;
    }
    ::ResumeThread(m_handle);
}

void CThread::Suspend()
{
    if(NULL == m_handle || !m_bRun)
    {
        return;
    }
    ::SuspendThread(m_handle);
}

bool CThread::Terminate(unsigned long ExitCode)
{
    if(NULL == m_handle || !m_bRun)
    {
        return true;
    }
    if(::TerminateThread(m_handle, ExitCode))
    {
        ::CloseHandle(m_handle);
        return true;
    }
    return false;
}

unsigned int CThread::GetThreadID()
{
    return m_ThreadID;
}

std::string CThread::GetThreadName()
{
    return m_ThreadName;
}

void CThread::SetThreadName(std::string ThreadName)
{
    m_ThreadName = ThreadName;
}

void CThread::SetThreadName(const char * ThreadName)
{
    if(NULL == ThreadName)
    {
        m_ThreadName = "";
    }
    else
    {
        m_ThreadName = ThreadName;
    }
}

unsigned int CThread::StaticThreadFunc(void * arg)
{
    CThread * pThread = (CThread *)arg;
    pThread->Run();
    return 0;
}

 

用法：

#include "Thread.h"
#include "ThreadPoolExecutor.h"

class R : public Runnable
{
public:
    ~R()
    {
        printf("~R/n");
    }
    void Run()
    {
        printf("Hello World/n");
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    R r;
    CThread * t = NULL;
    t = new CThread(&r);
    t->Start();
    t->Join();

    getchar();

}

 

from:http://blog.csdn.net/huyiyang2010/article/details/5801597