简单线程池实现

      线程池可以处理多线程问题，只要将任务放到任务队列中，线程池中的线程就会从队列中取任务，以默认的优先级开始执行，如果你的任务数大于正在工作的线程数，则线程池将会创建一根新的线程来辅助工作，但是永远都不会超过线程池中线程的最大值。

线程池的结构

#pragma once
#include <List>
#include <queue>
#include <windows.h>
#include <process.h>
using namespace std;

class MLock
{
public:
	MLock(void);
	~MLock(void);
public:
	CRITICAL_SECTION m_cs;
public:
	void Lock();
	void DLock();
};


class Itask
{
public:
	Itask(){}
	virtual ~Itask(){}
public:
	virtual void RunItask() = 0;
};

class MyThreadPool
{
public:
	MyThreadPool(void);
	~MyThreadPool(void);
public:
	//1.创建一些线程
	bool CreateThreadPool(long lMinThreadNum,long lMaxThreadNum);
	//2.销毁线程
	void DestroyThreadPool();
	//3.线程函数
	static unsigned __stdcall ThreadProc( void * );
	//4.投递任务
	bool PostItask(Itask*);
public:
	list<Itask*> m_qItask;
	list<HANDLE> m_Thread;
	bool m_bflagQuie;
	HANDLE m_Semaphore;
	long CreateThreadNum;
	volatile long RunThreadNum;
	long MaxThreadNum;
	MLock m_Lock;
};

创建线程：

bool MyThreadPool::CreateThreadPool(long lMinThreadNum,long lMaxThreadNum)
{
	if(lMinThreadNum < 0 || lMaxThreadNum < lMinThreadNum)
		return false;
	//创建一个信号量，来控制线程的激活个数
	m_Semaphore = CreateSemaphore(NULL, 0, lMaxThreadNum, NULL);
	for(long i = 0; i < lMinThreadNum; i++)
	{
		HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, &MyThreadPool::ThreadProc, this, 0, 0);
		//放到线程链表中
		if(hThread)
		{
			m_Thread.push_back(hThread);
		}
	}
	CreateThreadNum = lMinThreadNum;
	MaxThreadNum = lMaxThreadNum;
}

销毁线程：

void MyThreadPool::DestroyThreadPool()
{
	m_bflagQuie = false;
	list<HANDLE>::iterator ite = m_Thread.begin();
	Itask *pItask = NULL;
	while(ite != m_Thread.end())
	{
		if(WAIT_TIMEOUT == WaitForSingleObject(*ite, 100))
		{
			TerminateThread(*ite, -1);
		}
		CloseHandle(*ite);
		++ite;
	}
	while(m_qItask.size() != 0)
	{
		pItask = m_qItask.front();
		m_qItask.pop_front();
		pItask->RunItask();
		delete(pItask);
		pItask = NULL;
	}
	m_qItask.clear();
}

线程执行函数

unsigned __stdcall MyThreadPool::ThreadProc(void * lpvoid)
{
	MyThreadPool *pthis = (MyThreadPool*)lpvoid;
	Itask *pItask = NULL;
	while(pthis->m_bflagQuie)
	{
		//等信号量
		if(WAIT_TIMEOUT == WaitForSingleObject(pthis->m_Semaphore, 100))
			continue;
		pthis->RunThreadNum++;
		//判断队列是否为空
		while(pthis->m_qItask.size() > 0)
		{
			
			pthis->m_Lock.Lock();
			if(pthis->m_qItask.size() == 0)
			{
				pthis->m_Lock.DLock();
				break;
			}
			pItask = pthis->m_qItask.front();
			pthis->m_qItask.pop_front();
			pthis->m_Lock.DLock();
			pItask->RunItask();
			delete pItask;
			pItask = NULL;
		}
		pthis->RunThreadNum--;
		
	}
	return 0;
}

向线程池中投递任务：

bool MyThreadPool::PostItask(Itask* pItask)
{
	if(!pItask)
		return false;
	m_qItask.push_back(pItask);
	//有空闲的线程
	if(RunThreadNum < CreateThreadNum)
	{
		ReleaseSemaphore(m_Semaphore, 1, NULL);      //释放信号量
        }
	else if(CreateThreadNum < MaxThreadNum)//没有空闲的线程但是没达到最大值
	{
		HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, &MyThreadPool::ThreadProc, this, 0, 0);
		if(hThread)
		{
			m_Thread.push_back(hThread);
		}
		ReleaseSemaphore(m_Semaphore, 1, NULL);
		CreateThreadNum++;
	}
	else
	{
		//达到最大值
	}

	return 0;
}