一个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();

}