threadpool.cpp

通用 linux 线程池, 使用 C++ 编写, 具有良好的扩展性.

#include "threadpool.h"

namespace util
{

ThreadPool::ThreadPool(unsigned int _size):m_size(_size)
{
	m_idleCount = 0;
	m_bStoped = true;
	if(m_size < 1)
	{
		const_cast<unsigned int &>(m_size) = 1;
	}

	for(unsigned int i=0; i< m_size; i++)
	{
		shared_ptr<WorkThread>  hThread(new WorkThread(this));
		m_threadList.push_back(hThread);
		hThread->start();
	}
	m_idleCount = m_size;
	m_bStoped = false;
	sem_init(&m_sem,0,0);
}

ThreadPool::~ThreadPool(void)
{
	stop();
}

void ThreadPool::stop()
{
	if(! m_bStoped)
	{
		destroy();
		joinWithAllThreads();
		sem_destroy(&m_sem);
	}
}

void ThreadPool::addJob(const shared_ptr<BaseJob> job)
{
	if(m_bStoped)
	{	
		cout<<"-----The threadpool is destroyed. \n";
		return;
	}	
	AutoLock lock(&m_csJobList);
	m_jobList.push_back(job);
	sem_post(&m_sem);
}

void ThreadPool::destroy(void)
{
	for (unsigned int i = 0 ; i < m_size; ++i)
	{
		// ..NULL........
		shared_ptr<BaseJob> NULLJob;
		addJob(NULLJob);
	}
	m_bStoped = true;
}

bool ThreadPool::jobEmpty()
{
	AutoLock lock(&m_csJobList);
	return m_jobList.empty();
}

shared_ptr<BaseJob> ThreadPool::getJob()
{
	sem_wait(&m_sem);
	shared_ptr<BaseJob> job;
	{
		AutoLock lock(&m_csJobList);
		job = m_jobList.front();
		m_jobList.pop_front();
	}
    
	return job;
}

void ThreadPool::joinWithAllThreads()
{
//	for_each(m_threadList.begin(), m_threadList.end(), 
//		 mem_fun_ref_t(&WorkThread::join));
	
	list<shared_ptr<WorkThread> >::iterator it ;
	for(it = m_threadList.begin(); it != m_threadList.end(); it++)
	{
		shared_ptr<WorkThread> mthread = *it;
		mthread->join();
	}	

}
void ThreadPool::run(void)
{
	shared_ptr<BaseJob> job ;
	while(true)
	{
		{
			// ......
			AutoLock lock(&m_csThreadlist);
			job = getJob();
			{
				AutoLock lock(&m_idleMutex);
				--m_idleCount;
			}
			if(NULL == job.get())
			{
				break;
			}
		}
		
		job->run();
		{
			AutoLock lock(&m_idleMutex);
			++m_idleCount;			
		}		
	}
}

ThreadPool::WorkThread::WorkThread(const ThreadPool * _threadPool)
		: m_pool(const_cast<ThreadPool *> (_threadPool))
{}

void ThreadPool::WorkThread::run(void)
{
 	m_pool->run();
}

unsigned int ThreadPool::idleThreadCount(void)
{
	AutoLock lock(&m_idleMutex);
	return m_idleCount;
}

}