C++自定义线程池以及通过线程池处理业务展示

本实例通过3部分进行展示：

1. 将线程池定义成一个类，用来管理线程，该线程池设计成单例模式
2. 设计了一个工作类，即工作线程类，用于处理业务（使用基于事件的同步方式和原子操作同步方式）
3. 设计了一个任务分发管理类，用于模拟实际业务使用线程池实现处理业务

自定义事件类：.h
#pragma once
#include<windows.h>
class LanEvent
{
public:
LanEvent();
~LanEvent();

//线程等待时间触发信号
void Wait();

//触发线程事件信号
void Signal();

private:
HANDLE m_hEvent;
};

自定义事件类：.cpp
#include “stdafx.h”
#include “LanEvent.h”

LanEvent::LanEvent()
{
/*
//第二个参数：如果是true， 则此时即使WaitForSingleObject函数返回，其句柄也不会变为non-signaled状态，只能通过一下两个函数改变状态
BOOL ResetEvent(HANDLE hEvent); //to the non-signaled
BOOL SetEvent(HANDLE hEvent); //to the signaled
*/

m_hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
if (!m_hEvent)
{
	cout << "创建信号量失败！！！" << endl;
}

}

LanEvent::~LanEvent()
{
if (m_hEvent)
{
::CloseHandle(m_hEvent);
m_hEvent = NULL;
}
}

void LanEvent::Wait()
{
::WaitForSingleObject(m_hEvent, INFINITE);
::ResetEvent(m_hEvent);
}

void LanEvent::Signal()
{
if (m_hEvent)
{
::SetEvent(m_hEvent);
}
}

工作线程类： .h
#pragma once
#include “stdafx.h”
#include “LanEvent.h”
#include

/*
实现执行某一个函数
*/

//定义任务回调函数指针
typedef void(*Task)(VOID);

class LanWorkerThread
{
public:
LanWorkerThread();
~LanWorkerThread();

//开始运行
void Run();

//停止运行
void Stop();

//线程执行函数
static unsigned __stdcall  ThreadExec(void* pThis);

//线程真正的执行函数
void DoExec();

//设置任务的回调函数
void SetTask(Task task);

//获取使用状态
bool GetRunState() 
{ 
	return m_bRunState; 
}

//获取工作线程的句柄
HANDLE GetHandle() { return m_hdlThread; }

private:
//是否运行
bool m_bIsStop;

//使用状态
std::atomic<bool> m_bRunState;

//线程句柄
HANDLE m_hdlThread;

//本线程的执行的任务
Task m_task;

//事件同步对象
LanEvent m_eventCondition;

};

工作线程类： .cpp
#include “stdafx.h”
#include “LanWorkerThread.h”
#include <process.h> //for _beginthreadex

LanWorkerThread::LanWorkerThread()
{
m_bIsStop = false;
m_bRunState = false;
m_task = NULL;

m_hdlThread = (HANDLE)_beginthreadex(NULL, 0, &LanWorkerThread::ThreadExec, this, CREATE_SUSPENDED, NULL);	//第5个参数 0： 立即运行  CREATE_SUSPENDED: 悬挂（挂起） //也可以使用SuspendThread函数来挂起线程
if (m_hdlThread == 0)
{
	cout << "创建线程失败！！！" << endl;
}

}

LanWorkerThread::~LanWorkerThread()
{
if (m_hdlThread != 0)
{
//WaitForSingleObject函数用来检测hHandle事件的信号状态，在某一线程中调用该函数时，线程暂时挂起，如果在挂起的dwMilliseconds毫秒内，
//线程所等待的对象变为有信号状态，则该函数立即返回；如果超时时间已经到达dwMilliseconds毫秒，但hHandle所指向的对象还没有变成有信号状态，函数照样返回。
//WaitForSingleObject(m_hdlThread, INFINITE);
WaitForSingleObject(m_hdlThread, INFINITE);
cout << “线程ID：” << GetThreadId(m_hdlThread) << “退出!!!” << endl;
CloseHandle(m_hdlThread);
}

}

void LanWorkerThread::Run()
{
if (m_hdlThread)
{
//唤醒线程
ResumeThread(m_hdlThread);
}
else
{
cout << “线程HANDLE错误！！！”;
}
}

void LanWorkerThread::Stop()
{
m_bIsStop = true;
m_eventCondition.Signal();
}

unsigned __stdcall LanWorkerThread::ThreadExec(void* pThis)
{
LanWork