本文参考:http://www.cnblogs.com/lidabo/p/3328646.html
global.h
#ifndef __GLOBAL_H__
#define __GLOBAL_H__
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <list>
#include <set>
#include <pthread.h>
using namespace std;
class Task
{
public:
virtual ~Task() {};
virtual void Run() = 0;
};
class Thread;
class ThreadMgr;
#endif //__GLOBAL_H__
ThreadMgr.h
#ifndef __THREADMGR_H__
#define __THREADMGR_H__
#include "global.h"
class ThreadMgr
{
public:
ThreadMgr(void);
~ThreadMgr();
bool Init(unsigned int minThreads, unsigned int maxThreads, unsigned int maxPendingTaskse);
bool AddTask(Task* task);
int GetTaskNum() {return m_TaskNum;}
int GetThreadNum() {return m_ThreadNum;}
int GetBusyNum() {return m_BusyNum;}
private:
class Worker
{
public:
Worker(ThreadMgr * pThreadMgr, Task* ptask = NULL);
~Worker();
void Start();
void Terminate();
pthread_t m_id;
bool m_bwRun;
private:
static void* CallBack(void*);
ThreadMgr * m_pThreadMgr;
Task * m_pTask;
};
unsigned int m_minThreads; // 最少线程
unsigned int m_maxThreads; // 最多线程
unsigned int m_maxPendingTasks; // 创建新线程阀值
bool m_bRun; // 运行标志
bool m_bEnableInsertTask; // 可放任务标志
int m_TaskNum; // 待执行任务数量
int m_ThreadNum; // 总线程数量
int m_BusyNum; // 忙线程数量
typedef set<Worker *> THREADPOOL;
typedef list<Task *> TASKS;
typedef TASKS::iterator TasksItr;
typedef THREADPOOL::iterator ThreadPoolItr;
THREADPOOL m_BusyThreadPool;
THREADPOOL m_IdleThreadPool;
THREADPOOL m_TrashThreads;
TASKS m_Tasks;
pthread_mutex_t m_ThreadMutex;
pthread_mutex_t m_TaskMutex;
pthread_cond_t m_TaskCond;
Task * GetTask();
void TerminateAll();
bool MoveToIdlePool(Worker* worker);
bool MoveToBusyPool(Worker* worker);
};
#endif //__THREADMGR_H__
ThreadMgr.cpp
#include "ThreadMgr.h"
ThreadMgr::Worker::Worker(ThreadMgr * pThreadMgr, Task* ptask):
m_pThreadMgr(pThreadMgr),
m_pTask(ptask),
m_bwRun(true)
{
pthread_create(&m_id, NULL, CallBack, (void*)this);
}
ThreadMgr::Worker::~Worker()
{
}
void* ThreadMgr::Worker::CallBack(void* pv)
{
Worker* work = NULL;
if (pv != NULL)
work = (Worker*)pv;
work->Start();
return (void*)0;
}
void ThreadMgr::Worker::Terminate()
{
m_bwRun = false;
//pthread_exit(0);
pthread_join(m_id, NULL);
}
/**
执行任务的工作线程
**/
void ThreadMgr::Worker::Start()
{
Task * pTask = NULL;
while(m_bwRun)
{
if (m_pThreadMgr->m_bRun == false) // 退出标记
break;
if(NULL == m_pTask)
{
pTask = m_pThreadMgr->GetTask();
}
else
{
pTask = m_pTask;
m_pTask = NULL;
}
if(NULL == pTask) // 没有任务
{
pthread_mutex_lock(&(m_pThreadMgr->m_ThreadMutex));
// 当前总线程数量多于最小线程数量阀值 将自己放进垃圾池,总线程数减一
if(m_pThreadMgr->m_ThreadNum > m_pThreadMgr->m_minThreads)
{
ThreadPoolItr itr = m_pThreadMgr->m_IdleThreadPool.find(this);
if(itr != m_pThreadMgr->m_IdleThreadPool.end())
{
m_pThreadMgr->m_IdleThreadPool.erase(itr);
m_pThreadMgr->m_ThreadNum--;
m_pThreadMgr->m_TrashThreads.insert(this);
}
m_bwRun = false;
}
// 清理垃圾池, 然后等待执行任务信号
else
{
ThreadPoolItr itr = m_pThreadMgr->m_TrashThreads.begin();
while(itr != m_pThreadMgr->m_TrashThreads.end())
{
(*itr)->Terminate();
delete (*itr);
m_pThreadMgr->m_TrashThreads.erase(itr);
itr = m_pThreadMgr->m_TrashThreads.begin();
}
cout << " wait signal " << endl;
pthread_cond_wait(&(m_pThreadMgr->m_TaskCond), &(m_pThreadMgr->m_ThreadMutex));
cout << this->m_id << " get signal " << endl;
}
pthread_mutex_unlock(&(m_pThreadMgr->m_ThreadMutex));
continue;
}
else
if (pTask != NULL)
{
m_pThreadMgr->MoveToBusyPool(this);
pTask->Run();
m_pThreadMgr->MoveToIdlePool(this);
delete pTask;
pTask = NULL;
}
}
}
ThreadMgr::ThreadMgr():m_bRun(false), m_bEnableInsertTask(false)
{
m_ThreadMutex = PTHREAD_MUTEX_INITIALIZER;
m_TaskMutex = PTHREAD_MUTEX_INITIALIZER;
m_TaskCond = PTHREAD_COND_INITIALIZER;
}
ThreadMgr::~ThreadMgr()
{
TerminateAll();
pthread_mutex_destroy(&m_ThreadMutex);
pthread_mutex_destroy(&m_TaskMutex);
pthread_cond_destroy(&m_TaskCond);
}
/**
初始化
**/
bool ThreadMgr::Init(unsigned int minThreads, unsigned int maxThreads, unsigned int maxPendingTasks)
{ if (minThreads == 0 || maxThreads == 0 || maxPendingTasks <= 0)
return false;
if (minThreads < 5) minThreads = 5; // 最小线程阀值
if (maxThreads < 10) maxThreads = 10; // 最大线程阀值
m_ThreadNum = 0; // 总线程数量
m_TaskNum = 0; // 还未取走的任务数量
m_BusyNum = 0; // 忙碌线程数量
m_minThreads = minThreads;
m_maxThreads = maxThreads;
m_maxPendingTasks = maxPendingTasks; // 创建新线程阀值
unsigned int i = m_IdleThreadPool.size();
for(; i<minThreads; i++)
{
Worker* pWorker = new Worker(this);
m_IdleThreadPool.insert(pWorker);
++m_ThreadNum;
}
m_bRun = true;
m_bEnableInsertTask = true;
//cout << " Init end " << endl;
}
/**
从任务列表中取出一个任务
**/
Task * ThreadMgr::GetTask()
{
Task * ptask = NULL;
pthread_mutex_lock(&m_TaskMutex);
if(m_TaskNum > 0)
{
ptask = m_Tasks.front();
if (ptask != NULL)
{
m_TaskNum--;
m_Tasks.pop_front();
}
}
pthread_mutex_unlock(&m_TaskMutex);
return ptask;
}
/**
如果当前任务大于最大等待任务,查看线程是否达到最大线程数量,没达到则创建新线程
**/
bool ThreadMgr::AddTask(Task* task)
{
pthread_mutex_lock(&m_TaskMutex);
bool bsendSignal = false;
if (m_TaskNum == 0)
bsendSignal = true;
if(!m_bEnableInsertTask)
{
return false;
}
if(NULL == task)
{
return false;
}
// 任务数量大于最大等待数量
if(m_TaskNum >= m_maxPendingTasks)
{
if(m_ThreadNum < m_maxThreads) // 当前总线程少于最大线程数量 创建新线程
{
Worker * pWorker = new Worker(this, task);
//cout << " Create New Thread " << m_ThreadNum << ',' << m_BusyNum << endl;
if(NULL == pWorker) // 创建新线程失败,把任务放进队列,
{
m_Tasks.push_back(task);
++m_TaskNum;
pthread_mutex_unlock(&m_TaskMutex);
return true;
}
else // 创建新线程成功
{
pthread_mutex_lock(&m_ThreadMutex);
m_BusyThreadPool.insert(pWorker);
++m_ThreadNum;
pthread_mutex_unlock(&m_ThreadMutex);
pthread_mutex_unlock(&m_TaskMutex);
}
}
else // 当前线程等于或超过最大线程数量
{
m_Tasks.push_back(task);
++m_TaskNum;
pthread_mutex_unlock(&m_TaskMutex);
return true;
}
}
else
{
m_Tasks.push_back(task);
++m_TaskNum;
if (bsendSignal)
pthread_cond_signal(&m_TaskCond);
pthread_mutex_unlock(&m_TaskMutex);
}
return true;
}
/**
将指定线程放到空闲池
**/
bool ThreadMgr::MoveToIdlePool(Worker* worker)
{
pthread_mutex_lock(&m_ThreadMutex);
ThreadPoolItr it = m_BusyThreadPool.find(worker);
if (it != m_BusyThreadPool.end())
{
m_BusyThreadPool.erase(it);
m_IdleThreadPool.insert(worker);
m_BusyNum--;
pthread_mutex_unlock(&m_ThreadMutex);
return true;
}
pthread_mutex_unlock(&m_ThreadMutex);
return false;
}
/**
将指定线程放到忙碌池
**/
bool ThreadMgr::MoveToBusyPool(Worker* worker)
{
pthread_mutex_lock(&m_ThreadMutex);
ThreadPoolItr it = m_IdleThreadPool.find(worker);
if (it != m_IdleThreadPool.end())
{
m_IdleThreadPool.erase(it);
m_BusyThreadPool.insert(worker);
m_BusyNum++;
pthread_mutex_unlock(&m_ThreadMutex);
return true;
}
pthread_mutex_unlock(&m_ThreadMutex);
return false;
}
/**
结束所有线程,只需要清理空闲池,垃圾池被任务执行完后的第一个wait线程清理掉
**/
void ThreadMgr::TerminateAll()
{
//cout << " Terminate All " << endl;
m_bEnableInsertTask = false; // 不允许再放任务进来
while(m_TaskNum > 0) // 还有任务,等待任务执行完
{
sleep(1);
}
m_bRun = false; // 退出标记
m_minThreads = 0;
m_maxThreads = 0;
m_maxPendingTasks = 0;
while(m_BusyNum > 0) // 还有忙碌线程,等待执行结束
{
//cout << " Busy : " << m_BusyNum << endl;
sleep(1);
}
pthread_cond_broadcast(&m_TaskCond); // 唤醒所有睡眠线程,此时的task必然都为NULL,而且退出标记为true,所有线程都会退出无限循环
ThreadPoolItr it = m_IdleThreadPool.begin();
for (; it != m_IdleThreadPool.end(); ++it)
{
pthread_join((*it)->m_id, NULL);
//cout << (*it)->m_id << " terminated !" << endl;
}
for (it = m_IdleThreadPool.begin(); it != m_IdleThreadPool.end();)
{
delete (*it);
m_IdleThreadPool.erase(it);
it = m_IdleThreadPool.begin();
}
}
测试main.cpp
#include "global.h"
#include "ThreadMgr.h"
class MT : public Task
{
public:
MT(int num):m_num(num){}
int m_num;
void Run()
{
cout << " [" << m_num << ']';
}
};
int main(void)
{
ThreadMgr* pMgr = new ThreadMgr;
pMgr->Init(5, 10, 50);
for (int i=0; i<6000000; ++i)
{
MT *pm = new MT(i);
pMgr->AddTask(pm);
}
delete pMgr;
pMgr = NULL;
return 0;
}