跨windows和linux的线程类

//Thread.h

#ifndef _THREAD_H_
#define _THREAD_H_

#ifdef _WIN32
#	include <windows.h>
#	include <process.h>
#else
#	include <pthread.h>
#endif

//可运行基类
class IRunable {
public:
//构造函数
IRunable() {}

//析构函数
virtual ~IRunable() {}

//线程运行入口
virtual void run() = 0;

};

typedef unsigned int ThreadId;

class Thread : public IRunable {
public:
Thread();

/**
* @param target 线程运行目标
* @param release 目标对象是否由线程对象释放
*/
Thread(IRunable& target, bool release = true);

virtual ~Thread();

void start();

virtual void run();

void join();

void detach();

ThreadId getThreadId() const;

bool operator == (const Thread& rhs) const;

bool operator != (const Thread& rhs) const;

bool operator < (const Thread& rhs) const;

public:
static void start(IRunable& target);

static void sleep(int millis);

static ThreadId getCurrentThreadId();

static void yield();

private:
IRunable* _target;

bool _release;

#ifdef _WIN32
ThreadId _threadId;
HANDLE _pThread;
#else
pthread_t _pThread;
#endif
};

#endif //_THREAD_H_

//Thread.cpp

#include "Thread.h"

#ifdef _WIN32
#	include <process.h>
#endif

#include <iostream>

#include <exception>

using std::exception;

//线程运行入口
#ifdef _WIN32
unsigned int _stdcall
#else
void*
#endif
runEntry(void* target) {
try{
reinterpret_cast<IRunable*>(target)->run();
} catch(const exception& ex) {
std::cerr << ex.what() << std::endl;
} catch(...){
std::cerr << "run error" << std::endl;
}
return 0;
}

Thread::Thread() : _target(NULL), _release(false), _pThread(0) {
#ifdef _WIN32
_threadId = 0;
_pThread = INVALID_HANDLE_VALUE;
#else
_pThread = 0;
#endif
}

Thread::Thread(IRunable& target, bool release) : _target(&target), _release(release), _pThread(0) {
#ifdef _WIN32
_threadId = 0;
_pThread = INVALID_HANDLE_VALUE;
#else
_pThread = 0;
#endif
}

Thread::~Thread() {
if(_release)
delete _target;
}

//线程入口
void Thread::run() {}

void Thread::start() {
IRunable* target = _target ? _target : this;

#ifdef _WIN32
_pThread = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, runEntry, target, 0, &_threadId));
if(0 == _pThread) {
throw exception();//GetLastError()
}
#else
pthread_attr_t attr;
int rc = pthread_attr_init(&attr);
if(rc) {
throw exception();//errno
}

rc = pthread_create(&_pThread, &attr, runEntry, target);
if(rc) {
throw exception();//errno
}
#endif
}

void Thread::join() {

#ifdef _WIN32
if(_pThread && WaitForSingleObject(_pThread, INFINITE) != WAIT_OBJECT_0){
throw exception();//GetLastError()
}

detach();
#else
if(_pThread && pthread_join(_pThread, NULL) != 0) {
throw exception();//errno
}
#endif
}

void Thread::detach() {
#ifdef _WIN32
if(_pThread && CloseHandle(_pThread) == 0){
throw exception();//GetLastError()
}
#else
if(_pThread && pthread_detach(_pThread) != 0){
throw exception();//errno
}
#endif
}

ThreadId Thread::getThreadId() const {
#ifdef _WIN32
return _threadId;
#else
return _pThread;
#endif
}

bool Thread::operator == (const Thread& rhs) const {
return this == &rhs;
}

bool Thread::operator != (const Thread& rhs) const {
return this != &rhs;
}

bool Thread::operator < (const Thread& rhs) const {
return this < &rhs;
}

// static functions
void Thread::start(IRunable& target) {
Thread t(target, false);
t.start();
t.detach();
}

void Thread::sleep(int ms) {
#ifdef _WIN32
Sleep(ms);
#else
struct timespec ts;
ts.tv_sec = ms / 1000;
ts.tv_nsec = (ms % 1000) * 1000000;
nanosleep(&ts, 0);
#endif
}

ThreadId Thread::getCurrentThreadId() {
#ifdef _WIN32
return GetCurrentThreadId();
#else
return pthread_self();
#endif
}

void Thread::yield() {
#ifdef _WIN32
Sleep(0);
#else
sched_yield();
#endif
}

//main.cpp

#include "Thread.h"
#include <iostream>

class TestThread : public Thread {
public:
virtual void run() {
std::cout << "this is a thread test" << std::endl;
std::cout << Thread::getCurrentThreadId() << std::endl;
}
};

int main(int argc, char const *argv[])
{
TestThread test;
test.start();
//test.detach();
test.join();

return 0;
}