基于Windows事件设计线程和线程池

线程类

class CWTThread
{
public:
	CWTThread() :m_hThread(NULL), m_bStatus(false) {}
	~CWTThread() {Stop();}
	//True 表示成功 False 表示失败
	bool Start();
	bool IsValid();
	bool Stop();
	void UpdateWorker(const ::ThreadWorker& worker = ::ThreadWorker());
	//true 表示空闲 false 表示分配了工作
	bool IsIdle();
private:
		   void ThreadWorker();
	static void ThreadEntry(void* arg);
private:
	HANDLE m_hThread;
	bool m_bStatus;		//false 表示线程将要关闭 true 表示线程正在运行
	std::atomic<::ThreadWorker*>m_worker;
};

bool CWTThread::Start() {
	m_bStatus = true;
	m_hThread = (HANDLE)_beginthread(&CWTThread::ThreadEntry, 0, this);
	if (!IsValid())m_bStatus = false;
	return m_bStatus;
}//启动线程

bool CWTThread::IsValid() {//返回true表示有效 返回false表示无效
	if (m_hThread == NULL || (m_hThread == INVALID_HANDLE_VALUE))return false;
	return WaitForSingleObject(m_hThread, 0) == WAIT_TIMEOUT;
}//判断线程的有效性

bool CWTThread::Stop() {
	if (m_bStatus == false)return true;
	m_bStatus = false;
	DWORD ret = WaitForSingleObject(m_hThread, INFINITE) == WAIT_OBJECT_0;
	if (ret == WAIT_TIMEOUT) {
		TerminateThread(m_hThread, -1);
	}
	UpdateWorker();
	return ret;
}//线程停止执行

void CWTThread::UpdateWorker(const::ThreadWorker& worker) {
	if (m_worker.load() != NULL && m_worker.load() != &worker) {
		::ThreadWorker* pWorker = m_worker.load();
		m_worker.store(NULL);
		delete pWorker;
	}
	if (m_worker.load() == &worker)return;
	if (!worker.IsValid()) {
		m_worker.store(NULL);
		return;
	}
	
	m_worker.store(new ::ThreadWorker());
}//更新线程中执行的函数

void CWTThread::ThreadWorker() {
	while (m_bStatus) {
		if (m_worker.load() == NULL) {
			Sleep(1);
			continue;
		}
		::ThreadWorker worker = *m_worker.load();
		if (worker.IsValid()) {
			if (WaitForSingleObject(m_hThread, 0) == WAIT_TIMEOUT) {
				int ret = worker();
				if (ret != 0) {
					CString str;
					str.Format(_T("thread found warning code %d\r\n"), ret);
					OutputDebugString(str);
				}
				else if (ret < 0) {
					m_worker.store(NULL);
				}
			}
		}
		else {
			Sleep(1);
		}
	}
}//函数执行主体

void CWTThread::ThreadEntry(void* arg) {
	CWTThread* thiz = (CWTThread*)arg;
	if (thiz)thiz->ThreadWorker();
	_endthread();
}

线程函数执行主体

为了和灵活更改线程函数的执行主体，我们需要新定义一个类，用于让用户执行线程函数的执行主体

ThreadWorker中维护了两个变量，一个是ThreadFuncBase的指针以及一个成员函数指针，这个类会初始化基类指针以及成员函数指针，通过仿函数实现线程函数主体的调用。

//线程函数基类
class ThreadFuncBase {};
typedef int(ThreadFuncBase::* FUNCTYPE)();
//threadworker中维护了两个变量
class ThreadWorker {
public:
	ThreadWorker() :thiz(NULL), func(NULL) {}
	ThreadWorker(void* obj, FUNCTYPE f) :thiz((ThreadFuncBase*)obj), func(f) {}
	ThreadWorker(const ThreadWorker& worker) {
		thiz = worker.thiz;
		func = worker.func;
	}
	ThreadWorker& operator=(const ThreadWorker& worker) {
		if (this != &worker) {
			thiz = worker.thiz;
			func = worker.func;
		}
		return *this;
	}
	int operator()() {
		if (IsValid()) {
			return (thiz->*func)();
		}
		return -1;
	}
	bool IsValid() const { return thiz != NULL && func != NULL; }
	ThreadFuncBase* thiz;
	FUNCTYPE func;
};

线程池实现

class CWTThreadPool {
public:
	CWTThreadPool(size_t size);
	CWTThreadPool() {}
	~CWTThreadPool();
	bool Invoke();
	void Stop();
	int  DispatchWorker(const ThreadWorker& worker);
	bool CheckThreadValid(size_t index);
private:
	std::mutex m_lock;
	std::vector<CWTThread*>m_threads;
};

CWTThreadPool::CWTThreadPool(size_t size) {
	m_threads.resize(size);
	for (size_t i = 0; i < size; i++) {
		m_threads[i] = new CWTThread();
	}
}

bool CWTThreadPool::Invoke() {
	bool ret = true;
	for (size_t i = 0; i < m_threads.size(); i++) {
		if (m_threads[i]->Start() == false) {
			ret = false;
			break;
		}
	}
	if (ret == false) {
		for (size_t i = 0; i < m_threads.size(); i++) {
			m_threads[i]->Stop();
		}
	}
	return ret;
}

void CWTThreadPool::Stop() {
	for (size_t i = 0; i < m_threads.size(); i++) {
		m_threads[i]->Stop();
	}
}

int CWTThreadPool::DispatchWorker(const ThreadWorker& worker) {
	int index = -1;
	m_lock.lock();
	for (size_t i = 0; i < m_threads.size(); i++) {
		if (m_threads[i]->IsIdle()) {
			m_threads[i]->UpdateWorker(worker);
			index = i;
			break;
		}
	}
	m_lock.unlock();
	return index;
}

bool CWTThreadPool::CheckThreadValid(size_t index) {
	if (index < m_threads.size()) {
		return m_threads[index]->IsValid();
	}
	return false;
}