一个Windows C++的线程类实现（封装API，形成一个类，但不完善。其实可以学习一下Delphi的TThread的写法）

Thread.h

[cpp] view plain copy

#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

[cpp] view plain copy

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

}
http://blog.csdn.net/huyiyang2010/article/details/5801597