以前写的一个线程管理器--ThreadManager

windows下适当的使用多线程能增加程序运行效率，不过winapi自带的线程接口函数直接调用多了可能会有点乱，所以我对其进行了2次封装，增加了oo特性。

编译后生成ThreadManager.lib,ThreadManager.dll以供调用。

ThreadManager.h

#pragma once

#include<windows.h>
#include<map>
#include<vector>
#include"Common.h"

#define ACTIVED 0x0000
#define STOPPED 0x0001

class _declspec(dllexport) ThreadManager
{
private:
	
	std::vector<DWORD> m_nThreadFlag;										//线程标识容器
	int m_nThreadNum;														//线程数量
	int m_nMaxThreadNum;													//最大线程数量

public:
	ThreadManager(void);
	~ThreadManager(void);
	std::map<DWORD, SystemThread *>  m_PrimaryThreadPool;					//系统线程池
	void CreateNewThread(DWORD nThreadFlag, LPTHREAD_START_ROUTINE Func, LPVOID fPara, DWORD nActived);	//创建线程
	bool StopThread(DWORD nThreadFlag);										//挂起线程
	bool ReStartThread(DWORD nThreadFlag);									//激活线程
	bool DestroyThread(DWORD nThreadFlag, DWORD dwExitCode = 0);			//终止线程
	int GetThreadNum(void);													//获得线程数量
	void SetThreadNum(int nThreadNum);										//设定线程数量
	std::map<DWORD, SystemThread *> GetThreadInfo(void);					//获取所有线程
	SystemThread *GetThreadByFlag(DWORD nThreadFlag);						//根据标识获得线程
	void SetMaxThreadNum(int nThreadNum);									//设置最大线程数量
	int GetMaxThreadNum(void);								 				//获取最大线程数量
	std::vector<DWORD> GetThreadFlag(void);
};

ThreadManager.cpp

#include "StdAfx.h"
#include ".\threadmanager.h"

ThreadManager::ThreadManager(void)
{
	this->m_nThreadNum = 0;
}

ThreadManager::~ThreadManager(void)
{
	for(int i = 0; i < this->m_nThreadNum; i++)
	{
		this->DestroyThread(i + 1);
	}
}

void ThreadManager::CreateNewThread(DWORD nThreadFlag, LPTHREAD_START_ROUTINE Func, LPVOID fPara, DWORD nActived)
{
	DWORD temp;
	SystemThread *thread = (SystemThread *)malloc(sizeof(SystemThread));
	memset(thread, 0, sizeof(SystemThread));
	thread->hThread = CreateThread(NULL, 0, Func, fPara, nActived, &temp);
	thread->nTID = temp;
	if(nActived == 0)
	{
		thread->nStmt = ACTIVED;
	}
	else
	{
		thread->nStmt = STOPPED;
	}
	this->m_PrimaryThreadPool.insert(std::pair<DWORD, SystemThread *>(nThreadFlag, thread));
	this->m_nThreadNum++;
}

bool ThreadManager::StopThread(DWORD nThreadFlag)
{
	std::map<DWORD, SystemThread *>::iterator piter = this->m_PrimaryThreadPool.find(nThreadFlag);
	if(piter != this->m_PrimaryThreadPool.end())
	{
		if(piter->second->nStmt == STOPPED)
		{
			return false;
		}
		SuspendThread(piter->second);
		piter->second->nStmt = STOPPED;
		return true;
	}
	return false;
}

bool ThreadManager::ReStartThread(DWORD nThreadFlag)
{
	std::map<DWORD, SystemThread *>::iterator piter = this->m_PrimaryThreadPool.find(nThreadFlag);
	if(piter != this->m_PrimaryThreadPool.end())
	{
		if(piter->second->nStmt == ACTIVED)
		{
			return false;
		}
		ResumeThread(piter->second->hThread);
		piter->second->nStmt = ACTIVED;
		return true;
	}
	return false;
}

bool ThreadManager::DestroyThread(DWORD nThreadFlag, DWORD dwExitCode)
{
	std::map<DWORD, SystemThread *>::iterator piter = this->m_PrimaryThreadPool.find(nThreadFlag);
	if(piter != this->m_PrimaryThreadPool.end())
	{
		TerminateThread(piter->second->hThread, dwExitCode);
		free(piter->second);
		this->m_PrimaryThreadPool.erase(piter);
		for(std::vector<DWORD>::iterator piter = this->m_nThreadFlag.begin();
			piter != this->m_nThreadFlag.end(); ++piter)
		{
			if(*piter == nThreadFlag)
			{
				this->m_nThreadFlag.erase(piter);
			}
		}
		this->m_nThreadNum--;
		return true;
	}
	return false;
}

int ThreadManager::GetThreadNum()
{
	return this->m_nThreadNum;
}

std::map<DWORD, SystemThread *> ThreadManager::GetThreadInfo()
{
	return this->m_PrimaryThreadPool;
}

SystemThread *ThreadManager::GetThreadByFlag(DWORD nThreadFlag)
{
	std::map<DWORD, SystemThread *>::iterator piter = this->m_PrimaryThreadPool.find(nThreadFlag);
	if(piter != this->m_PrimaryThreadPool.end())
	{
		return piter->second;
	}
	return NULL;
}

void ThreadManager::SetThreadNum(int nThreadNum)
{
	this->m_nThreadNum = nThreadNum;	
}

void ThreadManager::SetMaxThreadNum(int nThreadNum)
{
	this->m_nMaxThreadNum = nThreadNum;
}

int ThreadManager::GetMaxThreadNum()
{
	return this->m_nMaxThreadNum;
}

std::vector<DWORD> ThreadManager::GetThreadFlag(void)
{
	return this->m_nThreadFlag;
}