一個線程類的實現（C++）

Demo中需要用到多線程，所以實現了一個線程類，貼在這裏。

目前適用於Windows 32/64平臺，後續會有改進，以期可以跨平臺使用。

頭文件ThreadX.h

#ifndef _THREAD_X_
#define _THREAD_X_
/*
*********************************************************************************************************
*
*                                     COMMON TASK AND SEMAPHORE
*
* Filename      : ThreadX.h
* Version       : V1.0
* Programmer(s) : xclyfe
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*                                        INCLUDE FILES
*********************************************************************************************************
*/
#include <stdio.h>
#include <string>
#include <windows.h>
#include <process.h>
using namespace std;

class ThreadX
{
public:
	string threadName;
protected:
	HANDLE m_handle;
	unsigned int m_threadId;
	string m_threadName;

public:
	ThreadX();
	virtual ~ThreadX();
	virtual void Start(bool bSuspend = false);

	string GetThreadName();
	void SetThreadName(string threadName);
	unsigned int GetThreadId();
	HANDLE GetThreadHandle();
public:
	unsigned long ResumeThreadX();
	unsigned long SuspendThreadX();
	int TerminateThreadX(unsigned long dwExitCode);
	int SetThreadPriorityX(int nPriority);
	int GetThreadPriorityX();
	void ExitThreadX(unsigned long dwExitCode);
	unsigned long WaitForSingleObjectX(unsigned long dwMilliseconds);
protected:
	static unsigned __stdcall ThreadStaticEntryPoint(void * pThis);
	static HANDLE BeginThreadX(void * _Security, unsigned _StackSize,void * _ArgList, unsigned _InitFlag, unsigned * _ThrdAddr);
	static HANDLE BeginThreadXDefault(void * _ArgList, unsigned int * threadId, bool bSuspend = false);
	virtual void ThreadEntryPoint() = 0;
};

#endif//_THREAD_X_

實現文件ThreadX.cpp

/*
*********************************************************************************************************
*
*                                     COMMON TASK AND SEMAPHORE
*
* Filename      : ThreadX.cpp
* Version       : V1.0
* Programmer(s) : xclyfe
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*                                        INCLUDE FILES
*********************************************************************************************************
*/
#include "ThreadX.h"

ThreadX::ThreadX():m_handle(NULL),m_threadId(0),m_threadName("")
{
}

ThreadX::~ThreadX()  
{
}

void ThreadX::Start(bool bSuspend)
{
	m_handle = ThreadX::BeginThreadXDefault(this,&m_threadId, bSuspend);
}

unsigned __stdcall ThreadX::ThreadStaticEntryPoint(void * pThis)  
{
	ThreadX * pthX = (ThreadX*)pThis;   // the tricky cast
	pthX->ThreadEntryPoint();           // now call the true entry-point-function
	return 1;                           // the thread exit code
}

HANDLE ThreadX::BeginThreadXDefault(void * _ArgList, unsigned int * threadId, bool bSuspend)
{
	unsigned _InitFlag = 0;
	if (bSuspend)
	{
		_InitFlag = CREATE_SUSPENDED;
	}
	return BeginThreadX(NULL, 
		0,
		_ArgList, 
		_InitFlag, 
		threadId);
}

HANDLE ThreadX::BeginThreadX(void * _Security, 
							 unsigned _StackSize,
							 void * _ArgList, 
							 unsigned _InitFlag, 
							 unsigned * _ThrdAddr)
{
	HANDLE    hth;  

	hth = (HANDLE)_beginthreadex( _Security,  // security  
		_StackSize,                           // stack size  
		ThreadX::ThreadStaticEntryPoint,      // start address
		_ArgList,                             // arg list  
		_InitFlag,                            // init flag
		_ThrdAddr);                           // thread id

	if ( hth == 0 )
	{
		printf("Failed to create thread\n");
	}
	return hth;
}

unsigned long ThreadX::ResumeThreadX()
{
	return ResumeThread(m_handle);
}

unsigned long ThreadX::SuspendThreadX()
{
	return SuspendThread(m_handle);
}

int ThreadX::TerminateThreadX(unsigned long dwExitCode)
{
	return TerminateThread(m_handle,dwExitCode);
}

int ThreadX::SetThreadPriorityX(int nPriority)
{
	return SetThreadPriority(m_handle,nPriority);
}

int ThreadX::GetThreadPriorityX()
{
	return GetThreadPriority(m_handle);
}

void ThreadX::ExitThreadX(unsigned long dwExitCode)
{
	ExitThread(dwExitCode);
}

unsigned long ThreadX::WaitForSingleObjectX(unsigned long dwMilliseconds)
{
	return WaitForSingleObject(m_handle,dwMilliseconds);
}

string ThreadX::GetThreadName()
{
	return m_threadName;
}

void ThreadX::SetThreadName(string threadName)
{
	m_threadName = threadName;
}

unsigned int ThreadX::GetThreadId()
{
	return m_threadId;
}

HANDLE ThreadX::GetThreadHandle()
{
	return m_handle;
}

使用：

使用ThreadX之前，需要從ThreadX繼承，並實現類ThreadX中的純虛函數virtual void ThreadEntryPoint() = 0;

ThreadEntryPoint即是線程的業務處理入口，需要用戶根據需求完成實現。

例如

#include "threadx.h"
class ThreadNew :
	public ThreadX
{
public:
	ThreadNew(void);
	virtual ~ThreadNew(void);
private:
	virtual void ThreadEntryPoint();
};

ThreadNew::ThreadNew(void)
{
}

ThreadNew::~ThreadNew(void)
{
}

void ThreadNew::ThreadEntryPoint()
{
	//...
}

int main()
{
	ThreadNew * thread = new ThreadNew();
	thread->Start();
        return 0;
}