C++Window环境下线程池实现

--------------------------------------------threadPool.h------------------------------------
#pragma once
#include <atomic>
#include <process.h>
#include <vector>
#include <mutex>
#include <Windows.h>
#include <atlstr.h>
#include <iostream>
typedef int (*FUNCTYPE)(void*);
class ThreadWorker {
public:
	ThreadWorker() : func(NULL) ,arg(arg){};
	ThreadWorker( FUNCTYPE f,void* arg = NULL) : func(f), arg(arg) {}
	ThreadWorker(const ThreadWorker& worker) {
		func = worker.func;
		arg = worker.arg;
	}
	ThreadWorker& operator=(const ThreadWorker& worker) {
		if (this != &worker) {
			func = worker.func;
			arg = worker.arg;
		}
		return *this;
	}

	int operator()(void* arg) {
		if (IsValid()) {
			return func(arg);
		}
		return -1;
	}
	bool IsValid() const {
		return (func != NULL);
	}

public:
	FUNCTYPE func;
	void* arg;
};


class MyThread
{
public:
	MyThread() {
		m_hThread = NULL;
		m_bStatus = false;
	}
	~MyThread() {

	}
	/*
	* 判断线程状态：
	* 返回true表示有效 返回false表示线程异常或者已经终止
	*/
	bool IsValid() {
		if (m_hThread == NULL || (m_hThread == INVALID_HANDLE_VALUE))return false;
		return WaitForSingleObject(m_hThread, 0) == WAIT_TIMEOUT;
	}
	/*
	* 启动线程：
	* 返回true表示成功 返回false表示失败
	*/
	bool Start() {
		m_bStatus = true;
		m_hThread = (HANDLE)_beginthread(&MyThread::ThreadEntry, 0, this);
		if (!IsValid()) {
			m_bStatus = false;
		}
		return m_bStatus;
	}
	/*
	* 关闭线程：
	* 返回true表示成功 返回false表示失败
	*/
	bool Stop() {
		if (m_bStatus == false)return true;
		m_bStatus = false;
		bool ret = WaitForSingleObject(m_hThread, INFINITE) == WAIT_OBJECT_0;
		UpdateWorker();
		return ret;
	}
	void UpdateWorker(const ::ThreadWorker& worker = ::ThreadWorker()) {
		if (m_worker.load() != NULL && m_worker.load() != &worker) {
			::ThreadWorker* pWorker = m_worker.load();
			m_worker.store(NULL);
			delete pWorker;
		}
		if (!worker.IsValid()) {
			m_worker.store(NULL);
			return;
		}
		m_worker.store(new ::ThreadWorker(worker));
	}
	/*
	* 检测当前线程是否被分配任务：
	* true：分配；false：未分配
	*/
	bool IsIdle() {
		if (m_worker == NULL)return true;
		return !m_worker.load()->IsValid();
	}

private:
	/*
	* 开启线程：
	* 调用系统API，开启一个系统线程
	*/
	static void ThreadEntry(void* arg) {    
		MyThread* thiz = (MyThread*)arg;
		if (thiz) {
			thiz->ThreadWorker();
		}
		_endthread();
	}
	/*
	* 执行线程：
	* 如果m_worker一直没有被分配任务，则一直循环，不会执行
	* 一旦被分配任务，就会执行函数
	*/
	void ThreadWorker() {
		while (m_bStatus) {
			if (m_worker == NULL) {
				Sleep(1);
				continue;
			}
			::ThreadWorker worker = *m_worker.load();
			if (worker.IsValid()) {
				int ret = worker(worker.arg);
				if (ret == -1) {
					std::cout << "thread found warning" << std::endl;
				}
				else{
					m_worker.store(NULL);
				}
			}
			else {
				Sleep(1);
			}
		}
	}
private:
	HANDLE m_hThread;//线程句柄
	bool m_bStatus;//线程当前状态
	std::atomic<::ThreadWorker*> m_worker;//存放一个线程类，主要包括函数

};

class MyThreadPool
{
public:
	MyThreadPool(size_t size) {
		m_threads.resize(size);
		for (size_t i = 0; i < size; i++)
			m_threads[i] = new MyThread();
	}
	MyThreadPool() {}
	~MyThreadPool() {
		Stop();
		for (size_t i = 0; i < m_threads.size(); i++)
		{
			MyThread* pThread = m_threads[i];
			m_threads[i] = NULL;
			delete pThread;
		}

		m_threads.clear();
	}
	//激活线程池
	bool 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 Stop() {
		for (size_t i = 0; i < m_threads.size(); i++) {
			m_threads[i]->Stop();
		}
	}

	//返回-1 表示分配失败，所有线程都在忙 大于等于0，表示第n个线程分配来做这个事情
	int DispatchWorker(const ThreadWorker& worker) {
		int index = -1;
		m_lock.lock();
		for (size_t i = 0; i < m_threads.size(); i++) {
			if (m_threads[i] != NULL && m_threads[i]->IsIdle()) {
				m_threads[i]->UpdateWorker(worker);
				index = i;
				break;
			}
		}
		m_lock.unlock();
		return index;
	}

	bool CheckThreadValid(size_t index) {
		if (index < m_threads.size()) {
			return m_threads[index]->IsValid();
		}
		return false;
	}
public:
	std::mutex m_lock;
	std::vector<MyThread*> m_threads;
};

using namespace std;
int thread1(void* arg) {
	cout << "thread1" << endl;
	return 0;
}
int thread2(void* arg) {
	int* a = (int*)arg;
	cout << "thread2  " << *a<<endl;
	return 0;
}
int main() {

	MyThreadPool pool(10);
	pool.Invoke();  //这里其实已经开了10个线程了，只是这10个线程一直循环等待任务
	ThreadWorker worker1(&thread1);
	int* a = new int(1);
	ThreadWorker worker2(&thread2, a);
	int index = -1;
	while (index == -1) {
		index = pool.DispatchWorker(worker1);
	}
	std::cout << index << std::endl;
	pool.m_threads[index]->UpdateWorker(worker1);//这里开始执行
	index = -1;
	while (index == -1) {
		index = pool.DispatchWorker(worker2);
	}
	std::cout << index << std::endl;
	pool.m_threads[index]->UpdateWorker(worker2);//这里开始执行
	Sleep(1000);
	std::cout << "主线程结束!" << std::endl;
	return 0;
}