Windows线程简单封装

#ifndef SPEND_THREAD_H_
#define SPEND_THREAD_H_

#include "Def.h"
#include <functional>
#include <string>

typedef std::tr1::function<void()> ThreadFunc;
class Thread
{
	DISALLOW_COPY_AND_ASSIGN(Thread);
public:
	explicit Thread(const ThreadFunc&, const std::string& name = std::string());
	~Thread();

	void start();
	void join();

	bool started() const { return started_; }
	const std::string name() const { return name_; }
	static int numCreated() { return numCreated_; }

private:
	static unsigned int __stdcall startThread(void* thread);
	void runInThread();

	bool started_;
	uintptr_t threadId_;
	ThreadFunc func_;
	std::string name_;
	static volatile unsigned int numCreated_;
};

#endif // SPEND_THREAD_H_

#include "stdafx.h"
#include "Thread.h"
#include <Windows.h>
#include <assert.h>
#include <process.h>

volatile unsigned int Thread::numCreated_ = 0;
Thread::Thread(const ThreadFunc& func, const std::string& name)
	: started_(false), threadId_(0), func_(func), name_(name)
{
	InterlockedIncrement(&numCreated_);
}

Thread::~Thread()
{
}

void Thread::start()
{
	assert(!started_);
	started_ = true;
	threadId_ = _beginthreadex(NULL, 0, startThread, this, 0, NULL);
	if (0 == threadId_)
	{
		OutputDebugString(L"create thread fail");
	}
	else
	{
		OutputDebugString(L"create thread success");
	}
}

void Thread::join()
{
	assert(started_);
	WaitForSingleObject((HANDLE)threadId_, INFINITE);
}

unsigned int Thread::startThread(void *obj)
{
	Thread *thread = static_cast<Thread*>(obj);
	thread->runInThread();
	return 0;
}

void Thread::runInThread()
{
	if (func_) { func_(); }
}