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

#ifndef __C_PLUS_THREAD_HEADER
#define __C_PLUS_THREAD_HEADER

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

using namespace std;

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

	// 开始运行线程
	BOOL Start(BOOL bSuspend=FALSE);

	// 运行线程虚函数，派生类重写该函数
	virtual void Run();
	
	//当前执行此函数线程等待线程结束 
    //timeout 等待超时时间，如果为负数，等待无限时长
	void Join(int timeout =-1);

	void Resume();
	void Suspend();

	BOOL Terminate(unsigned long Exitcode);

	unsigned int GetThreadID();
	string GetThreadName();
	
	void SetThreadName(std::string ThreadName);
	void SetThreadName(const char* ThreadName);
	
private:
	static unsigned int WINAPI StaticThreadFunc(void* argv);
	
private:
	HANDLE m_handle;
	Runnable* const m_pRunnable;
	unsigned int m_ThreadID;
	std::string m_ThreadName;
	volatile BOOL m_bRun;
};

#endif

// CThread.cpp: implementation of the CThread class.

#include "CThread.h"

CThread::CThread():m_pRunnable(NULL),m_bRun(FALSE)
{

}

CThread::~CThread()
{

}

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(const char* ThreadName)
{
	if (NULL == ThreadName)
	{
		m_ThreadName="";
	}
	else
	{
		m_ThreadName= ThreadName;
	}
}

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

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

#include <stdio.h>
#include "CThread.h"
#include "CThreadPoolExecutor.h"

class Example:public Runnable
{
public:
	~Example()
	{
		printf("Example Destruction\n");
	}

	void Run()
	{
		printf("Hello CThread\n");	
	}
};

int main(int argc, char* argvp[])
{

	CThreadPoolExecutor* pExecutor = new CThreadPoolExecutor();
	pExecutor->Init(2,10,50);
	Example exam;

	CThread * t = NULL;
    t = new CThread(&exam);
    t->Start();
    t->Join();

	getchar();
	return 0;
}