C++ 线程（二）

#include <process.h>

#include <iostream>

#include <windows.h>

#include <string>

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

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;

};

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)

{

cout << ThreadName << endl;

}

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;

}

class Test : public Runnable

{

public:

~Test()

{

printf("~test \n");

}

void Run()

{

printf("richard Hello World\n");

}

};

int main(int argc, char *argv[])

{

Test m;

CThread * t = NULL;

t = new CThread("cthread test",&m);

t->Start();

t->Join();

return 0;

}