C++ Thread Class

#pragma once
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
class Thread
{
protected:
	HANDLE Handle;
	DWORD ID;
	LPVOID m_lpThreadParam;
 
private:
	Thread(const Thread& bt);
	Thread& operator = (const Thread& bt) {};
	static DWORD WINAPI StaticThreadStart(LPVOID lpParam);
 
protected:
	virtual DWORD Run(void) = 0;
 
public:
	Thread();
	virtual ~Thread();
	bool Start(LPVOID lpThreadParam);
	void Stop();
 
	inline HANDLE GetThreadHandle();
	inline DWORD GetThreadID();
	inline bool IsRunning();
	inline void Join();
	inline BOOL Yeild();
	inline void Sleep(DWORD dsMilliiseconds);
	inline DWORD Suspend();
	inline DWORD Resume();
};

#include "Thread.h"
 
#include <stdexcept>
 
using namespace std;
 
DWORD WINAPI Thread::StaticThreadStart(LPVOID lpParam)
{
	Thread* pThread = (Thread*)lpParam;
	return pThread->Run();
}
 
Thread::Thread() : Handle(NULL), ID(0)
{
 
}
 
Thread::~Thread()
{
	if (Handle) CloseHandle(Handle);
}
 
bool Thread::Start(LPVOID lpThreadParam)
{
	if (Handle)
		{
		if (WaitForSingleObject(Handle, 0) == WAIT_TIMEOUT) {	// Thread Still Running
		return false;
		}
		CloseHandle(Handle);
	}
	m_lpThreadParam = lpThreadParam;
	Handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Thread::StaticThreadStart, this, 0, &ID);
	if (Handle != NULL) return true;
	return false;
}
 
void Thread::Stop()
{
	if (this->IsRunning()) {
		::TerminateThread(Handle, -1);
	}
	if (Handle) {
		CloseHandle(Handle);
		Handle = NULL;
	}
}
 
 
inline HANDLE Thread::GetThreadHandle() {
	return Handle;
}
 
inline DWORD Thread::GetThreadID()
{
	return ID;
}
 
inline bool Thread::IsRunning()
{
	if (Handle) {
		DWORD dwExitCode = 0;
		::GetExitCodeThread(Handle, &dwExitCode);
		if (dwExitCode == STILL_ACTIVE) return true;
	}
	return false;
}
 
inline void Thread::Join()
{
	::WaitForSingleObject(Handle, INFINITE);
}
 
inline BOOL Thread::Yeild()
{
	return ::SwitchToThread();
}
 
inline void Thread::Sleep(DWORD dsMilliiseconds)
{
	::Sleep(dsMilliiseconds);
}
 
inline DWORD Thread::Suspend()
{
	return ::SuspendThread(Handle);
}
 
inline DWORD Thread::Resume()
{
	return ::ResumeThread(Handle);
}
 
 
 
#include <cstdio>
 
class ThreadTest : public Thread
{
protected:
	virtual DWORD Run(void)
	{
		int nParam = *(int*)m_lpThreadParam;
		for(int i=1; i<=nParam; i++)
		{
			Sleep(200);
			printf("[TID %d]\t: %d\n", GetThreadID(), i);
		}
 
		return 0;
	}
};
 
int main()
{
	ThreadTest t1, t2;
	int nParam1 = 3;
	int nParam2 = 5;
	if(t1.Start((LPVOID)&nParam1) && t2.Start((LPVOID)&nParam2))
	{
		t1.Join();
		t2.Join();
	}
 
	printf("----------------\n");
 
	nParam1 = 2;
	nParam2 = 3;
	if(t1.Start((LPVOID)&nParam1) && t2.Start((LPVOID)&nParam2))
	{
		t1.Join();
		t2.Join();
	}
 
	t1.Stop();
	t2.Stop();
 
	return 0;
}

C:\test>Thread.exe
[TID 4160]      : 1
[TID 4268]      : 1
[TID 4268]      : 2
[TID 4160]      : 2
[TID 4160]      : 3
[TID 4268]      : 3
[TID 4160]      : 4
[TID 4160]      : 5
----------------
[TID 4952]      : 1
[TID 6092]      : 1
[TID 4952]      : 2
[TID 6092]      : 2
[TID 6092]      : 3