[C++][Thread] 转：线程池原理及创建（C++实现）

ps -ef f 
用树形显示进程和线程，比如说我想找到proftp现在有多少个进程/线程，可以用 
$ ps -ef f | grep proftpd 
nobody 23117 1 0 Dec23 ? S 0:00 proftpd:   (accepting   connections)   
jack 23121 23117 0 Dec23 ? S 7:57 /_ proftpd: jack - ftpsrv:   IDLE 
jack 28944 23117 0 Dec23 ? S 4:56 /_ proftpd: jack - ftpsrv:   IDLE 
这样就可以看到proftpd这个进程下面挂了两个线程。 
在Linux下面好像因为没有真正的线程，是用进程模拟的，有一个是辅助线程，所以真正程序开的线程应该只有一个。

 

另外用pstree -c也可以达到相同的效果 
$ pstree -c | grep proftpd 
|-proftpd-+-proftpd 
| `-proftpd

 

如何查看进程中各线程的内存占用情况？

用ps aux只能查看到进程，如果进程里面使用了pthread编程，用什么命令才能查询到进程里的线程资源占用？

ps aux | grep不就是了

    本文给出了一个通用的线程池框架，该框架将与线程执行相关的任务进行了高层次的抽象，使之与具体的执行任务无关。另外该线程池具有动态伸缩性，它能根据执行任务的轻重自动调整线程池中线程的数量。文章的最后，我们给出一个简单示例程序，通过该示例程序，我们会发现，通过该线程池框架执行多线程任务是多么的简单。

为什么需要线程池
    目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。
传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线程，由该线程执行任务。任务执行完毕后，线程退出，这就是是“即时创建，即时销毁”的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数极其频繁，那么服务器将处于不停的创建线程，销毁线程的状态。
我们将传统方案中的线程执行过程分为三个过程：T1、T2、T3。


T1：线程创建时间
T2：线程执行时间，包括线程的同步等时间
T3：线程销毁时间


那么我们可以看出，线程本身的开销所占的比例为(T1+T3) / (T1+T2+T3)。如果线程执行的时间很短的话，这比开销可能占到20%-50%左右。如果任务执行时间很频繁的话，这笔开销将是不可忽略的。

除此之外，线程池能够减少创建的线程个数。通常线程池所允许的并发线程是有上界的，如果同时需要并发的线程数超过上界，那么一部分线程将会等待。而传统方案中，如果同时请求数目为2000，那么最坏情况下，系统可能需要产生2000个线程。尽管这不是一个很大的数目，但是也有部分机器可能达不到这种要求。

因此线程池的出现正是着眼于减少线程池本身带来的开销。线程池采用预创建的技术，在应用程序启动之后，将立即创建一定数量的线程(N1)，放入空闲队列中。这些线程都是处于阻塞（Suspended）状态，不消耗CPU，但占用较小的内存空间。当任务到来后，缓冲池选择一个空闲线程，把任务传入此线程中运行。当N1个线程都在处理任务后，缓冲池自动创建一定数量的新线程，用于处理更多的任务。在任务执行完毕后线程也不退出，而是继续保持在池中等待下一次的任务。当系统比较空闲时，大部分线程都一直处于暂停状态，线程池自动销毁一部分线程，回收系统资源。
基于这种预创建技术，线程池将线程创建和销毁本身所带来的开销分摊到了各个具体的任务上，执行次数越多，每个任务所分担到的线程本身开销则越小，不过我们另外可能需要考虑进去线程之间同步所带来的开销。


构建线程池框架

一般线程池都必须具备下面几个组成部分：
线程池管理器:用于创建并管理线程池
工作线程: 线程池中实际执行的线程
任务接口: 尽管线程池大多数情况下是用来支持网络服务器，但是我们将线程执行的任务抽象出来，形成任务接口，从而是的线程池与具体的任务无关。
任务队列:线程池的概念具体到实现则可能是队列，链表之类的数据结构，其中保存执行线程。

我们实现的通用线程池框架由五个重要部分组成CThreadManage，CThreadPool，CThread，CJob，CWorkerThread，除此之外框架中还包括线程同步使用的类CThreadMutex和CCondition。
CJob是所有的任务的基类，其提供一个接口Run，所有的任务类都必须从该类继承，同时实现Run方法。该方法中实现具体的任务逻辑。
CThread是Linux中线程的包装，其封装了Linux线程最经常使用的属性和方法，它也是一个抽象类，是所有线程类的基类，具有一个接口Run。
CWorkerThread是实际被调度和执行的线程类，其从CThread继承而来，实现了CThread中的Run方法。
CThreadPool是线程池类，其负责保存线程，释放线程以及调度线程。
CThreadManage是线程池与用户的直接接口，其屏蔽了内部的具体实现。
CThreadMutex用于线程之间的互斥。
CCondition则是条件变量的封装，用于线程之间的同步。
它们的类的继承关系如下图所示：

线程池的时序很简单，如下图所示。CThreadManage直接跟客户端打交道，其接受需要创建的线程初始个数，并接受客户端提交的任务。这儿的任务是具体的非抽象的任务。CThreadManage的内部实际上调用的都是CThreadPool的相关操作。CThreadPool创建具体的线程，并把客户端提交的任务分发给CWorkerThread，CWorkerThread实际执行具体的任务。

理解系统组件

下面我们分开来了解系统中的各个组件。
CThreadManage
CThreadManage的功能非常简单，其提供最简单的方法，其类定义如下：

class CThreadManage
{
private:
    CThreadPool* m_Pool;
    int m_NumOfThread;
protected:
public:
    void SetParallelNum(int num);
    CThreadManage();
    CThreadManage(int num);
    virtual ~CThreadManage();

    void Run(CJob* job,void* jobdata);
    void TerminateAll(void);
}; 

其中m_Pool指向实际的线程池；m_NumOfThread是初始创建时候允许创建的并发的线程个数。另外Run和TerminateAll方法也非常简单，只是简单的调用CThreadPool的一些相关方法而已。其具体的实现如下:

CThreadManage::CThreadManage(){
	m_NumOfThread = 10;
	m_Pool = new CThreadPool(m_NumOfThread);
}

CThreadManage::CThreadManage(int num){
	m_NumOfThread = num;
	m_Pool = new CThreadPool(m_NumOfThread);
}

CThreadManage::~CThreadManage(){
	if(NULL != m_Pool)
	delete m_Pool;
}

void CThreadManage::SetParallelNum(int num){
	m_NumOfThread = num;
}

void CThreadManage::Run(CJob* job,void* jobdata){
	m_Pool->Run(job,jobdata);
}

void CThreadManage::TerminateAll(void){
	m_Pool->TerminateAll();
}

CThread
CThread 类实现了对Linux中线程操作的封装，它是所有线程的基类，也是一个抽象类，提供了一个抽象接口Run，所有的CThread都必须实现该Run方法。CThread的定义如下所示：

class CThread
{
private:
	int m_ErrCode;
	Semaphore m_ThreadSemaphore; //the inner semaphore, which is used to realize
	unsigned long m_ThreadID;
	bool m_Detach; //The thread is detached
	bool m_CreateSuspended; //if suspend after creating
	char* m_ThreadName;
	ThreadState m_ThreadState; //the state of the thread
	
protected:
	void SetErrcode(int errcode){m_ErrCode = errcode;}
	static void* ThreadFunction(void*);
	
public:
	CThread();
	CThread(bool createsuspended,bool detach);
	virtual ~CThread();
	virtual void Run(void) = 0;
	void SetThreadState(ThreadState state){m_ThreadState = state;}
	
	bool Terminate(void); //Terminate the threa
	bool Start(void); //Start to execute the thread
	void Exit(void);
	bool Wakeup(void);
	
	ThreadState GetThreadState(void){return m_ThreadState;}
	int GetLastError(void){return m_ErrCode;}
	void SetThreadName(char* thrname){strcpy(m_ThreadName,thrname);}
	char* GetThreadName(void){return m_ThreadName;}
	int GetThreadID(void){return m_ThreadID;}
	
	bool SetPriority(int priority);
	int GetPriority(void);
	int GetConcurrency(void);
	void SetConcurrency(int num);
	bool Detach(void);
	bool Join(void);
	bool Yield(void);
	int Self(void);
};  

线程的状态可以分为四种，空闲、忙碌、挂起、终止(包括正常退出和非正常退出)。由于目前Linux线程库不支持挂起操作，因此，我们的此处的挂起操作类似于暂停。如果线程创建后不想立即执行任务，那么我们可以将其“暂停”，如果需要运行，则唤醒。有一点必须注意的是，一旦线程开始执行任务，将不能被挂起，其将一直执行任务至完毕。
线程类的相关操作均十分简单。线程的执行入口是从Start()函数开始，其将调用函数ThreadFunction，ThreadFunction再调用实际的Run函数，执行实际的任务。

CThreadPool
CThreadPool是线程的承载容器，一般可以将其实现为堆栈、单向队列或者双向队列。在我们的系统中我们使用STL Vector对线程进行保存。CThreadPool的实现代码如下：

class CThreadPool
{
	
friend class CWorkerThread;

private:
	unsigned int m_MaxNum; //the max thread num that can create at the same time
	unsigned int m_AvailLow; //The min num of idle thread that shoule kept
	unsigned int m_AvailHigh; //The max num of idle thread that kept at the same time
	unsigned int m_AvailNum; //the normal thread num of idle num;
	unsigned int m_InitNum; //Normal thread num;
protected:
	CWorkerThread* GetIdleThread(void);
	
	void AppendToIdleList(CWorkerThread* jobthread);
	void MoveToBusyList(CWorkerThread* idlethread);
	void MoveToIdleList(CWorkerThread* busythread);
	
	void DeleteIdleThread(int num);
	void CreateIdleThread(int num);
public:
	CThreadMutex m_BusyMutex; //when visit busy list,use m_BusyMutex to lock and unlock
	CThreadMutex m_IdleMutex; //when visit idle list,use m_IdleMutex to lock and unlock
	CThreadMutex m_JobMutex; //when visit job list,use m_JobMutex to lock and unlock
	CThreadMutex m_VarMutex;
	
	CCondition m_BusyCond; //m_BusyCond is used to sync busy thread list
	CCondition m_IdleCond; //m_IdleCond is used to sync idle thread list
	CCondition m_IdleJobCond; //m_JobCond is used to sync job list
	CCondition m_MaxNumCond;
	
	vector<CWorkerThread*> m_ThreadList;
	vector<CWorkerThread*> m_BusyList; //Thread List
	vector<CWorkerThread*> m_IdleList; //Idle List
	
	CThreadPool();
	CThreadPool(int initnum);
	virtual ~CThreadPool();
	
	void SetMaxNum(int maxnum){m_MaxNum = maxnum;}
	int GetMaxNum(void){return m_MaxNum;}
	void SetAvailLowNum(int minnum){m_AvailLow = minnum;}
	int GetAvailLowNum(void){return m_AvailLow;}
	void SetAvailHighNum(int highnum){m_AvailHigh = highnum;}
	int GetAvailHighNum(void){return m_AvailHigh;}
	int GetActualAvailNum(void){return m_AvailNum;}
	int GetAllNum(void){return m_ThreadList.size();}
	int GetBusyNum(void){return m_BusyList.size();}
	void SetInitNum(int initnum){m_InitNum = initnum;}
	int GetInitNum(void){return m_InitNum;}
	
	void TerminateAll(void);
	void Run(CJob* job,void* jobdata);
};

CThreadPool::CThreadPool()
{
	m_MaxNum = 50;
	m_AvailLow = 5;
	m_InitNum=m_AvailNum = 10 ;
	m_AvailHigh = 20;
	
	m_BusyList.clear();
	m_IdleList.clear();
	for(int i=0;i<m_InitNum;i++){
		CWorkerThread* thr = new CWorkerThread();
		thr->SetThreadPool(this);
		AppendToIdleList(thr);
		thr->Start();
}
}

CThreadPool::CThreadPool(int initnum)
{
	assert(initnum>0 && initnum<=30);
	m_MaxNum = 30;
	m_AvailLow = initnum-10>0?initnum-10:3;
	m_InitNum=m_AvailNum = initnum ;
	m_AvailHigh = initnum+10;
	
	m_BusyList.clear();
	m_IdleList.clear();
	for(int i=0;i<m_InitNum;i++){
		CWorkerThread* thr = new CWorkerThread();
		AppendToIdleList(thr);
		thr->SetThreadPool(this);
		thr->Start(); //begin the thread,the thread wait for job
	}
}

CThreadPool::~CThreadPool()
{
	TerminateAll();
}

void CThreadPool::TerminateAll()
{
	for(int i=0;i < m_ThreadList.size();i++) {
		CWorkerThread* thr = m_ThreadList[i];
		thr->Join();
	}
	return;
}

CWorkerThread* CThreadPool::GetIdleThread(void)
{
	while(m_IdleList.size() ==0 )
	m_IdleCond.Wait();
	
	m_IdleMutex.Lock();
	if(m_IdleList.size() > 0 )
	{
		CWorkerThread* thr = (CWorkerThread*)m_IdleList.front();
		printf("Get Idle thread %dn",thr->GetThreadID());
		m_IdleMutex.Unlock();
		return thr;
	}
	m_IdleMutex.Unlock();
	
	return NULL;
}

//add an idle thread to idle list
void CThreadPool::AppendToIdleList(CWorkerThread* jobthread)
{
	m_IdleMutex.Lock();
	m_IdleList.push_back(jobthread);
	m_ThreadList.push_back(jobthread);
	m_IdleMutex.Unlock();
}

//move and idle thread to busy thread
void CThreadPool::MoveToBusyList(CWorkerThread* idlethread)
{
	m_BusyMutex.Lock();
	m_BusyList.push_back(idlethread);
	m_AvailNum--;
	m_BusyMutex.Unlock();
	
	m_IdleMutex.Lock();
	vector<CWorkerThread*>::iterator pos;
	pos = find(m_IdleList.begin(),m_IdleList.end(),idlethread);
	if(pos !=m_IdleList.end())
	m_IdleList.erase(pos);
	m_IdleMutex.Unlock();
}

void CThreadPool::MoveToIdleList(CWorkerThread* busythread)
{
	m_IdleMutex.Lock();
	m_IdleList.push_back(busythread);
	m_AvailNum++;
	m_IdleMutex.Unlock();
	
	m_BusyMutex.Lock();
	vector<CWorkerThread*>::iterator pos;
	pos = find(m_BusyList.begin(),m_BusyList.end(),busythread);
	if(pos!=m_BusyList.end())
	m_BusyList.erase(pos);
	m_BusyMutex.Unlock();
	
	m_IdleCond.Signal();
	m_MaxNumCond.Signal();
}

//create num idle thread and put them to idlelist
void CThreadPool::CreateIdleThread(int num)
{
	for(int i=0;i<num;i++){
		CWorkerThread* thr = new CWorkerThread();
		thr->SetThreadPool(this);
		AppendToIdleList(thr);
		m_VarMutex.Lock();
		m_AvailNum++;
		m_VarMutex.Unlock();
		thr->Start(); //begin the thread,the thread wait for job
	}
}

void CThreadPool::DeleteIdleThread(int num)
{
	printf("Enter into CThreadPool::DeleteIdleThreadn");
	m_IdleMutex.Lock();
	printf("Delete Num is %dn",num);
	for(int i=0;i<num;i++){
		CWorkerThread* thr;
		if(m_IdleList.size() > 0 ){
			thr = (CWorkerThread*)m_IdleList.front();
			printf("Get Idle thread %dn",thr->GetThreadID());
		}
	
		vector<CWorkerThread*>::iterator pos;
		pos = find(m_IdleList.begin(),m_IdleList.end(),thr);
		if(pos!=m_IdleList.end())
			m_IdleList.erase(pos);
		m_AvailNum--;
		printf("The idle thread available num:%d n",m_AvailNum);
		printf("The idlelist num:%d n",m_IdleList.size());
	}
	m_IdleMutex.Unlock();
}
void CThreadPool::Run(CJob* job,void* jobdata)
{
	assert(job!=NULL);
	
	//if the busy thread num adds to m_MaxNum,so we should wait
	if(GetBusyNum() == m_MaxNum)
	m_MaxNumCond.Wait();
	
	if(m_IdleList.size()<m_AvailLow)
	{
		if(GetAllNum()+m_InitNum-m_IdleList.size() < m_MaxNum )
			CreateIdleThread(m_InitNum-m_IdleList.size());
		else
			CreateIdleThread(m_MaxNum-GetAllNum());
	}

	CWorkerThread* idlethr = GetIdleThread();
	if(idlethr !=NULL)
	{
		idlethr->m_WorkMutex.Lock();
		MoveToBusyList(idlethr);
		idlethr->SetThreadPool(this);
		job->SetWorkThread(idlethr);
		printf("Job is set to thread %d n",idlethr->GetThreadID());
		idlethr->SetJob(job,jobdata);
	}
} 

在CThreadPool中存在两个链表，一个是空闲链表，一个是忙碌链表。Idle链表中存放所有的空闲进程，当线程执行任务时候，其状态变为忙碌状态，同时从空闲链表中删除，并移至忙碌链表中。在CThreadPool的构造函数中，我们将执行下面的代码:

for(int i=0;i<m_InitNum;i++)
{
	CWorkerThread* thr = new CWorkerThread();
	AppendToIdleList(thr);
	thr->SetThreadPool(this);
	thr->Start(); //begin the thread,the thread wait for job
} 

在该代码中，我们将创建m_InitNum个线程，创建之后即调用AppendToIdleList放入Idle链表中，由于目前没有任务分发给这些线程，因此线程执行Start后将自己挂起。
事实上，线程池中容纳的线程数目并不是一成不变的，其会根据执行负载进行自动伸缩。为此在CThreadPool中设定四个变量：
m_InitNum：处世创建时线程池中的线程的个数。
m_MaxNum:当前线程池中所允许并发存在的线程的最大数目。
m_AvailLow:当前线程池中所允许存在的空闲线程的最小数目，如果空闲数目低于该值，表明负载可能过重，此时有必要增加空闲线程池的数目。实现中我们总是将线程调整为m_InitNum个。
m_AvailHigh：当前线程池中所允许的空闲的线程的最大数目，如果空闲数目高于该值，表明当前负载可能较轻，此时将删除多余的空闲线程，删除后调整数也为m_InitNum个。
m_AvailNum：目前线程池中实际存在的线程的个数，其值介于m_AvailHigh和m_AvailLow之间。如果线程的个数始终维持在m_AvailLow和m_AvailHigh之间，则线程既不需要创建，也不需要删除，保持平衡状态。因此如何设定m_AvailLow和m_AvailHigh的值，使得线程池最大可能的保持平衡态，是线程池设计必须考虑的问题。
线程池在接受到新的任务之后，线程池首先要检查是否有足够的空闲池可用。检查分为三个步骤：
(1)检查当前处于忙碌状态的线程是否达到了设定的最大值m_MaxNum，如果达到了，表明目前没有空闲线程可用，而且也不能创建新的线程，因此必须等待直到有线程执行完毕返回到空闲队列中。
(2)如果当前的空闲线程数目小于我们设定的最小的空闲数目m_AvailLow，则我们必须创建新的线程，默认情况下，创建后的线程数目应该为m_InitNum，因此创建的线程数目应该为( 当前空闲线程数与m_InitNum);但是有一种特殊情况必须考虑，就是现有的线程总数加上创建后的线程数可能超过m_MaxNum，因此我们必须对线程的创建区别对待。

if(GetAllNum()+m_InitNum-m_IdleList.size() < m_MaxNum )
	CreateIdleThread(m_InitNum-m_IdleList.size());
else
	CreateIdleThread(m_MaxNum-GetAllNum()); 

如果创建后总数不超过m_MaxNum，则创建后的线程为m_InitNum；如果超过了，则只创建( m_MaxNum-当前线程总数 )个。
(3)调用GetIdleThread方法查找空闲线程。如果当前没有空闲线程，则挂起；否则将任务指派给该线程，同时将其移入忙碌队列。
当线程执行完毕后，其会调用MoveToIdleList方法移入空闲链表中，其中还调用m_IdleCond.Signal()方法，唤醒GetIdleThread()中可能阻塞的线程。

CWorkerThread
CWorkerThread是CThread的派生类，是事实上的工作线程。在CThreadPool的构造函数中，我们创建了一定数量的CWorkerThread。一旦这些线程创建完毕，我们将调用Start()启动该线程。Start方法最终会调用Run方法。Run方法是个无限循环的过程。在没有接受到实际的任务的时候，m_Job为NULL，此时线程将调用Wait方法进行等待，从而处于挂起状态。一旦线程池将具体的任务分发给该线程，其将被唤醒，从而通知线程从挂起的地方继续执行。CWorkerThread的完整定义如下:

class CWorkerThread:public CThread
{
private:
	CThreadPool* m_ThreadPool;
	CJob* m_Job;
	void* m_JobData;
	
	CThreadMutex m_VarMutex;
	bool m_IsEnd;
protected:
public:
	CCondition m_JobCond;
	CThreadMutex m_WorkMutex;
	CWorkerThread();
	virtual ~CWorkerThread();
	void Run();
	void SetJob(CJob* job,void* jobdata);
	CJob* GetJob(void){return m_Job;}
	void SetThreadPool(CThreadPool* thrpool);
	CThreadPool* GetThreadPool(void){return m_ThreadPool;}
};

CWorkerThread::CWorkerThread()
{
	m_Job = NULL;
	m_JobData = NULL;
	m_ThreadPool = NULL;
	m_IsEnd = false;
}

CWorkerThread::~CWorkerThread()
{
	if(NULL != m_Job)
		delete m_Job;
	if(m_ThreadPool != NULL)
		delete m_ThreadPool;
}

void CWorkerThread::Run()
{
	SetThreadState(THREAD_RUNNING);
	for(;;)
	{
		while(m_Job == NULL)
			m_JobCond.Wait();
			
			m_Job->Run(m_JobData);
			m_Job->SetWorkThread(NULL);
			m_Job = NULL;
			m_ThreadPool->MoveToIdleList(this);
		if(m_ThreadPool->m_IdleList.size() > m_ThreadPool->GetAvailHighNum())
		{
			m_ThreadPool->DeleteIdleThread(m_ThreadPool->m_IdleList.size()-m_T
			hreadPool->GetInitNum());
		}
		m_WorkMutex.Unlock();
	}
}
void CWorkerThread::SetJob(CJob* job,void* jobdata)
{
	m_VarMutex.Lock();
	m_Job = job;
	m_JobData = jobdata;
	job->SetWorkThread(this);
	m_VarMutex.Unlock();
	m_JobCond.Signal();
}
void CWorkerThread::SetThreadPool(CThreadPool* thrpool)
{
	m_VarMutex.Lock();
	m_ThreadPool = thrpool;
	m_VarMutex.Unlock();
} 

当线程执行任务之前首先必须判断空闲线程的数目是否低于m_AvailLow，如果低于，则必须创建足够的空闲线程，使其数目达到m_InitNum个，然后将调用MoveToBusyList()移出空闲队列，移入忙碌队列。当任务执行完毕后，其又调用MoveToIdleList()移出忙碌队列，移入空闲队列，等待新的任务。
除了Run方法之外，CWorkerThread中另外一个重要的方法就是SetJob，该方法将实际的任务赋值给线程。当没有任何执行任务即m_Job为NULL的时候，线程将调用m_JobCond.Wait进行等待。一旦Job被赋值给线程，其将调用m_JobCond.Signal方法唤醒该线程。由于m_JobCond属于线程内部的变量，每个线程都维持一个m_JobCond，只有得到任务的线程才被唤醒，没有得到任务的将继续等待。无论一个线程何时被唤醒，其都将从等待的地方继续执行m_Job->Run(m_JobData)，这是线程执行实际任务的地方。
在线程执行给定Job期间，我们必须防止另外一个Job又赋给该线程，因此在赋值之前，通过m_VarMutex进行锁定， Job执行期间，其于的Job将不能关联到该线程；任务执行完毕，我们调用m_VarMutex.Unlock()进行解锁，此时，线程又可以接受新的执行任务。
在线程执行任务结束后返回空闲队列前，我们还需要判断当前空闲队列中的线程是否高于m_AvailHigh个。如果超过m_AvailHigh，则必须从其中删除(m_ThreadPool->m_IdleList.size()-m_ThreadPool->GetInitNum())个线程，使线程数目保持在m_InitNum个。

CJob
CJob类相对简单，其封装了任务的基本的属性和方法，其中最重要的是Run方法，代码如下：

class CJob
{
private:
	int m_JobNo; //The num was assigned to the job
	char* m_JobName; //The job name
	CThread *m_pWorkThread; //The thread associated with the job
public:
	CJob( void );
virtual ~CJob();

	int GetJobNo(void) const { return m_JobNo; }
	void SetJobNo(int jobno){ m_JobNo = jobno;}
	char* GetJobName(void) const { return m_JobName; }
	void SetJobName(char* jobname);
	CThread *GetWorkThread(void){ return m_pWorkThread; }
	void SetWorkThread ( CThread *pWorkThread ){
		m_pWorkThread = pWorkThread;
	}
	
virtual void Run ( void *ptr ) = 0;
};

CJob::CJob(void)
	:m_pWorkThread(NULL)
	,m_JobNo(0)
	,m_JobName(NULL)
{
	
}
CJob::~CJob(){
	if(NULL != m_JobName)
		free(m_JobName);
}
void CJob::SetJobName(char* jobname)
{
	if(NULL !=m_JobName) {
		free(m_JobName);
		m_JobName = NULL;
	}
	if(NULL !=jobname) {
		m_JobName = (char*)malloc(strlen(jobname)+1);
		strcpy(m_JobName,jobname);
	}
} 

线程池使用示例
至此我们给出了一个简单的与具体任务无关的线程池框架。使用该框架非常的简单，我们所需要的做的就是派生CJob类，将需要完成的任务实现在Run方法中。然后将该Job交由CThreadManage去执行。下面我们给出一个简单的示例程序

class CXJob:public CJob
{
public:
	CXJob(){i=0;}
	~CXJob(){}
	void Run(void* jobdata) {
		printf("The Job comes from CXJOB\n");
		sleep(2);
	}
};

class CYJob:public CJob
{
public:
	CYJob(){i=0;}
	~CYJob(){}
	void Run(void* jobdata) {
		printf("The Job comes from CYJob\n");
	}
};

main()
{
	CThreadManage* manage = new CThreadManage(10);
	for(int i=0;i<40;i++)
	{
		CXJob* job = new CXJob();
		manage->Run(job,NULL);
	}
	sleep(2);
	CYJob* job = new CYJob();
	manage->Run(job,NULL);
	manage->TerminateAll();
} 

CXJob和CYJob都是从Job类继承而来，其都实现了Run接口。CXJob只是简单的打印一句”The Job comes from CXJob”，CYJob也只打印”The Job comes from CYJob”，然后均休眠2秒钟。在主程序中我们初始创建10个工作线程。然后分别执行40次CXJob和一次CYJob。
线程池使用后记
线程池适合场合
事实上，线程池并不是万能的。它有其特定的使用场合。线程池致力于减少线程本身的开销对应用所产生的影响，这是有前提的，前提就是线程本身开销与线程执行任务相比不可忽略。如果线程本身的开销相对于线程任务执行开销而言是可以忽略不计的，那么此时线程池所带来的好处是不明显的，比如对于FTP服务器以及Telnet服务器，通常传送文件的时间较长，开销较大，那么此时，我们采用线程池未必是理想的方法，我们可以选择“即时创建，即时销毁”的策略。
总之线程池通常适合下面的几个场合：
(1) 单位时间内处理任务频繁而且任务处理时间短
(2) 对实时性要求较高。如果接受到任务后在创建线程，可能满足不了实时要求，因此必须采用线程池进行预创建。
(3) 必须经常面对高突发性事件，比如Web服务器，如果有足球转播，则服务器将产生巨大的冲击。此时如果采取传统方法，则必须不停的大量产生线程，销毁线程。此时采用动态线程池可以避免这种情况的发生。

结束语
本文给出了一个简单的通用的与任务无关的线程池的实现，通过该线程池能够极大的简化Linux下多线程的开发工作。该线程池的进一步完善开发工作还在进行中，希望能够得到你的建议和支持。
参考资料
http://www-900.ibm.com/developerWorks/cn/java/j-jtp0730/index.shtml
POSIX多线程程序设计，David R.Butenhof 译者：于磊 曾刚，中国电力出版社
C++面向对象多线程编程，CAMERON HUGHES等著 周良忠译，人民邮电出版社
Java Pro,结合线程和分析器池,Edy Yu
关于作者
张中庆，西安交通大学软件所，在读硕士，目前研究方向为分布式网络与移动中间件，对Linux极其爱好，可以通过[email protected]与我联系。

linux下的c++线程池实现

我设计这个线程池的初衷是为了与socket对接的。线程池的实现千变万化，我得这个并不一定是最好的，但却是否和我心目中需求模型的。现把部分设计思路和代码贴出，以期抛砖引玉。个人比较喜欢搞开源，所以大家如果觉得有什么需要改善的地方，欢迎给予评论。思前想后，也没啥设计图能表达出设计思想，就把类图贴出来吧。

类图设计如下：

Command类是我们的业务类。这个类里只能存放简单的内置类型，这样方便与socket的直接传输。我定义了一个cmd_成员用于存放命令字，arg_用于存放业务的参数。这个参数可以使用分隔符来分隔各个参数。我设计的只是简单实现，如果有序列化操作了，完全不需要使用我这种方法啦。

ThreadProcess就是业务处理类，这里边定义了各个方法用于进行业务处理，它将在ThreadPool中的Process函数中调用。

ThreadPool就是我们的线程池类。其中的成员变量都是静态变量，Process就是线程处理函数。

#define MAX_THREAD_NUM 50 // 该值目前需要设定为初始线程数的整数倍
#define ADD_FACTOR 40 // 该值表示一个线程可以处理的最大任务数
#define THREAD_NUM 10 // 初始线程数

bshutdown_：用于线程退出。

command_：用于存放任务队列

command_cond_：条件变量

command_mutex_：互斥锁

icurr_thread_num_：当前线程池中的线程数

thread_id_map_：这个map用于存放线程对应的其它信息，我只存放了线程的状态，0为正常，1为退出。还可以定义其它的结构来存放更多的信息，例如存放套接字。

InitializeThreads：用于初始化线程池，先创建THREAD_NUM个线程。后期扩容也需要这个函数。

Process：线程处理函数，这里边会调用AddThread和DeleteThread在进行线程池的伸缩。

AddWork：往队列中添加一个任务。

ThreadDestroy：线程销毁函数。

AddThread：扩容THREAD_NUM个线程

DeleteThread：如果任务队列为空，则将原来的线程池恢复到THREAD_NUM个。这里可以根据需要进行修改。

 

以下贴出代码以供大家参考。

command.h

#ifndef COMMAND_H_
#define COMMAND_H_

class Command
{
public:
    int get_cmd();
    char* get_arg();
    void set_cmd(int cmd);
    void set_arg(char* arg);
private:
    int cmd_;
    char arg_[65];
};

#endif /* COMMAND_H_ */

command.cpp

#include <string.h>
#include "command.h"


int Command::get_cmd()
{
    return cmd_;
}

char* Command::get_arg()
{
    return arg_;
}

void Command::set_cmd(int cmd)
{
    cmd_ = cmd;
}

void Command::set_arg(char* arg)
{
    if(NULL == arg)
    {
        return;
    }
    strncpy(arg_,arg,64);
    arg_[64] = '\0';
}

thread_process.h

#ifndef THREAD_PROCESS_H_
#define THREAD_PROCESS_H_

class ThreadProcess
{
public:
    void Process0(void* arg);
    void Process1(void* arg);
    void Process2(void* arg);
};

#endif /* THREAD_PROCESS_H_ */

thread_process.cpp

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include "thread_process.h"


void ThreadProcess::Process0(void* arg)
{
    printf("thread %u is starting process %s\n",pthread_self(),arg);
    usleep(100*1000);
}
void ThreadProcess::Process1(void* arg)
{
    printf("thread %u is starting process %s\n",pthread_self(),arg);
    usleep(100*1000);
}

void ThreadProcess::Process2(void* arg)
{
    printf("thread %u is starting process %s\n",pthread_self(),arg);
    usleep(100*1000);
}

thread_pool.h

#ifndef THREAD_POOL_H_
#define THREAD_POOL_H_

#include <map>
#include <vector>
#include "command.h"

#define MAX_THREAD_NUM 50 // 该值目前需要设定为初始线程数的整数倍
#define ADD_FACTOR 40 // 该值表示一个线程可以处理的最大任务数
#define THREAD_NUM 10 // 初始线程数

class ThreadPool
{
public:
    ThreadPool() {};
    static void InitializeThreads();
    void AddWork(Command command);
    void ThreadDestroy(int iwait = 2);
private:
    static void* Process(void* arg);
    static void AddThread();
    static void DeleteThread();
    static bool bshutdown_;
    static int icurr_thread_num_;
    static std::map<pthread_t,int> thread_id_map_;
    static std::vector<Command> command_;
    static pthread_mutex_t command_mutex_;
    static pthread_cond_t command_cond_;
};


#endif /* THREAD_POOL_H_ */

thread_pool.cpp

#include <pthread.h>
#include <stdlib.h>
#include "thread_pool.h"
#include "thread_process.h"
#include "command.h"

bool ThreadPool::bshutdown_ = false;
int ThreadPool::icurr_thread_num_ = THREAD_NUM;
std::vector<Command> ThreadPool::command_;
std::map<pthread_t,int> ThreadPool::thread_id_map_;
pthread_mutex_t ThreadPool::command_mutex_ = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t ThreadPool::command_cond_ = PTHREAD_COND_INITIALIZER;

void ThreadPool::InitializeThreads()
{
    for (int i = 0; i < THREAD_NUM ; ++i)
    {
        pthread_t tempThread;
        pthread_create(&tempThread, NULL, ThreadPool::Process, NULL);
        thread_id_map_[tempThread] = 0;
    }
}

void* ThreadPool::Process(void* arg)
{
    ThreadProcess threadprocess;
    Command command;
    while (true)
    {
        pthread_mutex_lock(&command_mutex_);
        // 如果线程需要退出，则此时退出
        if (1 == thread_id_map_[pthread_self()])
        {
            pthread_mutex_unlock(&command_mutex_);
            printf("thread %u will exit\n", pthread_self());
            pthread_exit(NULL);
        }
        // 当线程不需要退出且没有需要处理的任务时，需要缩容的则缩容，不需要的则等待信号
        if (0 == command_.size() && !bshutdown_)
        {
            if(icurr_thread_num_ >  THREAD_NUM)
            {
                DeleteThread();
                if (1 == thread_id_map_[pthread_self()])
                {
                    pthread_mutex_unlock(&command_mutex_);
                    printf("thread %u will exit\n", pthread_self());
                    pthread_exit(NULL);
                }
            }
            pthread_cond_wait(&command_cond_,&command_mutex_);
        }
        // 线程池需要关闭，关闭已有的锁，线程退出
        if(bshutdown_)
        {
            pthread_mutex_unlock (&command_mutex_);
            printf ("thread %u will exit\n", pthread_self ());
            pthread_exit (NULL);
        }
        // 如果线程池的最大线程数不等于初始线程数，则表明需要扩容
        if(icurr_thread_num_ < command_.size()))
        {
            AddThread();
        }
        // 从容器中取出待办任务
        std::vector<Command>::iterator iter = command_.begin();
        command.set_arg(iter->get_arg());
        command.set_cmd(iter->get_cmd());
        command_.erase(iter);
        pthread_mutex_unlock(&command_mutex_);
        // 开始业务处理
        switch(command.get_cmd())
        {
        case 0:
            threadprocess.Process0(command.get_arg());
            break;
        case 1:
            threadprocess.Process1(command.get_arg());
            break;
        case 2:
            threadprocess.Process2(command.get_arg());
            break;
        default:
            break;
        }
    }
    return NULL; // 完全为了消除警告(eclipse编写的代码，警告很烦人)
}

void ThreadPool::AddWork(Command command)
{
    bool bsignal = false;
    pthread_mutex_lock(&command_mutex_);
    if (0 == command_.size())
    {
        bsignal = true;
    }
    command_.push_back(command);
    pthread_mutex_unlock(&command_mutex_);
    if (bsignal)
    {
        pthread_cond_signal(&command_cond_);
    }
}

void ThreadPool::ThreadDestroy(int iwait)
{
    while(0 != command_.size())
    {
        sleep(abs(iwait));
    }
    bshutdown_ = true;
    pthread_cond_broadcast(&command_cond_);
    std::map<pthread_t,int>::iterator iter = thread_id_map_.begin();
    for (; iter!=thread_id_map_.end(); ++iter)
    {
        pthread_join(iter->first,NULL);
    }
    pthread_mutex_destroy(&command_mutex_);
    pthread_cond_destroy(&command_cond_);
}

void ThreadPool::AddThread()
{
    if(((icurr_thread_num_*ADD_FACTOR) < command_.size())
            && (MAX_THREAD_NUM != icurr_thread_num_))
    {
        InitializeThreads();
        icurr_thread_num_ += THREAD_NUM;
    }
}

void ThreadPool::DeleteThread()
{
    int size = icurr_thread_num_ - THREAD_NUM;
    std::map<pthread_t,int>::iterator iter = thread_id_map_.begin();
    for(int i=0; i<size; ++i,++iter)
    {
        iter->second = 1;
    }
}

main.cpp

#include "thread_pool.h"
#include "command.h"

int main()
{
    ThreadPool thread_pool;
    thread_pool.InitializeThreads();
    Command command;
    char arg[8] = {0};
    for(int i=1; i<=1000; ++i)
    {
        command.set_cmd(i%3);
        sprintf(arg,"%d",i);
        command.set_arg(arg);
        thread_pool.AddWork(command);
    }
    sleep(10); // 用于测试线程池缩容
    thread_pool.ThreadDestroy();
    return 0;
}

 

代码是按照google的开源c++编码规范编写。大家可以通过改变那几个宏的值来调整线程池。有问题大家一起讨论。

from:http://www.cnblogs.com/osyun/archive/2012/08/31/2664938.html


最近看了一个Thread类（忘记在哪里看的了），感觉不错。
创建线程时线程对应的函数必须是类的静态成员，由于静态成员无法访问类的非静态成员，我从前都是把对象的指针作为参数传递给线程函数来避免这个问题，但是在逻辑上线程函数还需要访问对象的私有成员，总是感觉代码很不优雅。这个Thread类同java中的Thread类在用法上比较类似，使用一种比较优雅的方法避免了上面的问题。使用时只要从Thread派生一个子类并实现线程运行的函数 void run() 就可以了。还是看代码吧：

先把使用方法贴上来：

C++语言: 
#include<iostream>

#include "Thread.h"

class MyThreadClass: public Thread
{
private:
    int a;
public:
    MyThreadClass( ){
        a = 0;
    }
    ~MyThreadClass(){
    }
    virtual void run();
};

void Receiver::run(){
    a++;
    std::cout<<a<<std::endl;
}

int main(int argc, char * argv[])
{
    MyThreadClass myThread;
    myThread.start();//创建了一个线程,运行函数run()
    myThread.join();//等待线程结束
    return 0;
}

下面是Thread类的实现，为了阅读清晰，删减了很多内容

C++语言: Thread.h
#ifndef COMMUNITCATE_H
#define COMMUNITCATE_H



#include "pthread.h"


class Thread
{
protected:
    pthread_t _tid;
    static void* run0(void* opt);
    void* run1();//如果类中有保存线程状态的变量，可以在这个函数中可以进行更改操作
public:
    Thread();
    ~Thread();
    /** 
     * 创建线程，线程函数是 run0 
     * 
     * @return 成功返回 ture 否则返回 false
     */
    bool start();
    /** 
     * join this thread
     * 
     */
    void join();
    virtual void run(){
        
    }
};


#endif



C++语言: Thread.cpp
#include "Thread.h"

Thread::Thread(){
    
}

Thread::~Thread(){
    
}



void* Thread::run0(void* opt)
{
    Thread* p = (Thread*) opt;
    p->run1();
    return p;
}

void* Thread::run1()
{
    _tid = pthread_self();
    run();
    _tid = 0;
    pthread_exit(NULL);
}

bool Thread::start()
{
    return pthread_create(&_tid, NULL, run0, this) == 0;
}

void Thread::join()
{
    if( _tid > 0 ){
        pthread_join(_tid, NULL);
    }
}