一个线程池和一个先进先出的任务队列。
任务队列的模型是生产者消费者,队列的中的元素是function类型的对象实例,同时队列也是线程安全的。
线程池中的所有线程在没有任务时处于阻塞状态,有任务时被唤醒。
未完成待完成代码:
#include<iostream>
#include<pthread.h>
#include<cstdio>
#include<list>
#include<exception>
using namespace std;
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/lock_types.hpp>
#include <boost/thread/condition_variable.hpp>
using namespace boost;
typedef boost::mutex CMutex;
typedef boost::condition_variable_any CCondVar;
typedef boost::lock_guard<CMutex> CLockGuard;
typedef boost::unique_lock<CMutex> CUniqueLock;
typedef boost::thread_group CThreadGroup;
class CSemaphore{
private:
int iResCnt;
CMutex oMutex;
CCondVar oCondVar;
public:
explicit CSemaphore(unsigned int res = 0) : iResCnt(res){}
void Release(){
{
CLockGuard oLockGuard(oMutex);
iResCnt = iResCnt + 1;
}
oCondVar.notify_one();
}
void WaitFor(){
CUniqueLock oUniqueLock(oMutex);
while(iResCnt == 0){ oCondVar.wait(oUniqueLock); }
iResCnt = iResCnt - 1;
}
};
class CJob{
private:
int iTaskId;
public:
};
class CJobQueue{
private:
bool bExit;
std::list<Job> lstJob;
CMutex oMutexLst;
CCondition oCondJobInc;
public:
CJobQueue(){ bExit = false;}
~CJobQueue(){}
void PutIntoQueue(const CJob& job){
CScopedLock oScopedLock(oMutexLst);
lstJob.push_back(job);
oCondJobInc.notify_all();
}
void NotifyAll(){
bExit = true;//通知所有线程退出
oCondJobInc.notify_all();//唤醒所有线程
}
CJob GetFromQueue(){
CScopedLock oScopedLock(oMutexLst);
while(lstJob.size() == 0 && !bExit){ oCondJobInc.wait(oScopedLock); }
CJob oJob;
if(bExit) return oJob;
oJob = lstJob.front(); lstJob.pop_front();
return oJob;
}
};
class CThreadPool{
private:
int iThreads;//线程的数量
int iRequests;//请求队列的最大容量
CThreadGroup oThreadGroup;//线程组
//TaskQueue;//请求队列
CMutex oMutexQueue;//保护请求队列的互斥锁
CSemaphore oSemaphoreTask;//请求队列中是否有任务要处理
bool bStop;//是否结束线程
public:
CThreadPool(int threads = 8, int requests = 100) : iThreas(threads), iRequests(requests){
if((iThreads <= 0) || (iRequests <= 0)) throw std::exception();
for(int i = 0; i < threads; i++){
oThreadGroup.create_thread(boost::bind(&CThreadGroupEx::Run, this, i));
}
}
~CThreadPool(){
oThreadGroup.join_all();
}
};
template<typename T>
class threadpool
{
threadpool(int thread_number=8,int max_requests=1000);
~threadpool();
bool append(T* request); //向请求队列中添加请求
private:
static void* worker(void *arg); //线程执行函数
void run(); //实际运行线程的函数
};
template<typename T>
threadpool<T>::threadpool(int thread_number,int max_requests)
:m_thread_number(thread_number)
,m_max_requests(max_requests)
,m_stop(false)
,m_threads(NULL)
{
if((thread_number<=0)||(max_requests<=0))
{
throw std::exception();
}
m_threads=new pthread_t[thread_number];
if(!m_threads)
{
throw std::exception();
}
for(int i=0;i<thread_number;i++) //创建thread_number个线程,并且将其设置为分离状态
{
if(pthread_create(m_threads+i,NULL,worker,(void*)this)!=0)
{
delete [] m_threads;
throw std::exception();
}
if(pthread_detach(m_threads[i]))
{
delete [] m_threads;
throw std::exception();
}
}
}
template<typename T>
threadpool<T>::~threadpool()
{
delete [] m_threads;
m_stop=true;
}
template<typename T>
bool threadpool<T>::append(T* request) //向请求队列中添加请求任务
{
m_queuelocker.lock();
if(m_workqueue.size()>m_max_requests) //确保请求队列中没有被任务堆积满
{
m_queuelocker.unlock();
return false;
}
m_workqueue.push_back(request);
m_queuelocker.unlock();
m_queuestat.post(); //没添加一个任务,信号量增加
return true;
}
template<typename T>
void* threadpool<T>::worker(void *arg)
{
threadpool *pool=(threadpool*)arg;
pool->run(); //调用run函数处理请求队列中的请求任务
return pool;
}
template<typename T>
void threadpool<T>::run() //处理请求队列中的请求任务
{
while(!m_stop)
{
m_queuestat.wait();
m_queuelocker.lock();
if(m_workqueue.empty())
{
m_queuelocker.unlock();
continue;
}
T* request=m_workqueue.front();
m_workqueue.pop_front();
m_queuelocker.unlock();
request->process(); //process是任务类里面的一个方法
}
}