--------------------------------------------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;
}