Linux下通用线程池的构建

转自：http://blog.csdn.net/tingya/article/details/226614 

这篇文章是04年的文章，比较老了，但思路不错（原文中缺少图，自己做了添加，代码也修改了一部分，如果觉得有问题可以一起讨论）

另外，这篇文章的思路可以参考，但实际设计类的时候感觉不是太合理。有太多的相互引用，以至于看完代码之后感觉很混乱。

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

为什么需要线程池

目前的大多数网络服务器，包括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  
{
public:
	CThreadManage();
    CThreadManage(int num);

	virtual ~CThreadManage();

    void SetParallelNum(int num);
	void Run(CJob* job, void* jobArgs);
    void TerminateAll(void);

private:
	//线程池
	CThreadPool* m_Pool;
	//线程池中的数量
	int m_NumOfThread;
};


其中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(m_Pool != NULL)
		delete m_Pool;
}

//设置并行执行的线程数量
void CThreadManage::SetParallelNum(int num)
{
    m_NumOfThread = num;
}

//具体的执行交给ThreadPool处理
void CThreadManage::Run(CJob* job,void* jobArgs)
{
    m_Pool->Run(job,jobArgs);
}

//调用ThreadPool，以终结所有的线程
void CThreadManage::TerminateAll(void)
{
    m_Pool->TerminateAll();
}
CThreadPool
CThreadPool是线程的承载容器，一般可以将其实现为堆栈、单向队列或者双向队列。在我们的系统中我们使用STL Vector对线程进行保存。CThreadPool的实现代码如下：
头文件：
class CThreadPool  
{
public:
	CThreadPool();
	CThreadPool(int initnum);

    virtual ~CThreadPool();

	//访问忙碌队列的互斥锁
    CThreadMutex m_BusyMutex;
	//访问空闲队列的互斥锁
	CThreadMutex m_IdleMutex;
	//访问工作队列
    CThreadMutex m_JobMutex;
    CThreadMutex m_VarMutex;

	//访问忙碌队列的条件变量
    CCondition m_BusyCond;
	//访问空闲队列的条件变量
    CCondition m_IdleCond;
	//同步工作队列
    CCondition m_IdleJobCond;
    CCondition m_MaxNumCond;
 
    vector<CWorkerThread*>   m_ThreadList;
	//忙碌队列
    vector<CWorkerThread*>   m_BusyList;
	//空闲队列
    vector<CWorkerThread*>   m_IdleList;

	//设置或获取线程池允许存在的最大的线程数
	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()
	{
		return m_AvailHigh;
	}

	//获得实际可用的线程数量（处于空闲状态）
    int GetActualAvailNum()
	{
		return m_AvailNum;
	}
	//获得所有线程的数量
    int GetAllNum()
	{
		return m_ThreadList.size();
	}
	//获得运行状态的线程数量
    int GetBusyNum()
	{
		return m_BusyList.size();
	}

	//设置或获取初始时线程的数量
    void SetInitNum(int initnum)
	{
		m_InitNum = initnum;
	}
    int GetInitNum()
	{
		return m_InitNum;
	}

	//终止所有线程
	void TerminateAll();
	//执行任务
    void Run(CJob* job,void* jobdata);

	friend class CWorkerThread;

private:

	//允许创建的最大线程数量
    unsigned int m_MaxNum;
	//允许的最少空闲线程数量
    unsigned int m_AvailLow;
	//允许的最大空闲线程数量
    unsigned int m_AvailHigh;    
	//现有的空闲线程数量
    unsigned int m_AvailNum; 
	//初始时的线程数量
    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);
};
实现文件：
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* workThread = new CWorkerThread();
	    workThread->SetThreadPool(this);
		//添加到空闲队列
	    AppendToIdleList(workThread);
	    workThread->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* workThread = new CWorkerThread();
		//添加到空闲队列中
	    AppendToIdleList(workThread);
	    workThread->SetThreadPool(this);
	    workThread->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* workThread = m_ThreadList[i];
		//等待线程终止
	    workThread->Join();
    }
}

//获得空闲线程 
CWorkerThread* CThreadPool::GetIdleThread(void)
{
	//判断条件，并获取所
    while(m_IdleList.size() ==0)
		m_IdleCond.Wait();
    m_IdleMutex.Lock();

    if(m_IdleList.size() > 0)
    {
		//返回空闲队列首部的成员
	    CWorkerThread * workThread = (CWorkerThread*) m_IdleList.front();
	    printf("Get Idle thread %d/n",workThread->GetThreadID());
	    m_IdleMutex.Unlock();
	    return workThread;
    }

	//获取失败
    m_IdleMutex.Unlock();
    return NULL;
}

//增加一个工作线程到空闲队列
void CThreadPool::AppendToIdleList(CWorkerThread* jobthread)
{
    m_IdleMutex.Lock();
	//在所有的线程队列和空闲队列尾部增加一个线程
    m_ThreadList.push_back(jobthread);
    m_IdleList.push_back(jobthread);

    m_IdleMutex.Unlock();
}

//把空闲线程移动到忙碌队列中
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();
}

//创建指定数量的线程，并添加到空闲队列中
void CThreadPool::CreateIdleThread(int num)
{
    for(int i=0; i<num; i++)
	{
	    CWorkerThread* newThread = new CWorkerThread();
	    newThread->SetThreadPool(this);
		//把线程加入到空闲队列中
		AppendToIdleList(newThread);

		m_VarMutex.Lock();
	    m_AvailNum++;
	    m_VarMutex.Unlock();

		newThread->Start();       //begin the thread,the thread wait for job
    }
}

//删除指定数量的线程
void CThreadPool::DeleteIdleThread(int num)
{
    printf("Enter into CThreadPool::DeleteIdleThread/n");
    printf("Delete Num is %d/n", num);

    m_IdleMutex.Lock();
    for(int i=0; i<num; i++)
	{
	    CWorkerThread* removeThread;
	    if( m_IdleList.size() > 0 )
		{
            removeThread = (CWorkerThread*) m_IdleList.front();
            printf("Get Idle thread %d/n",removeThread->GetThreadID());
	    }

		//在空闲队列中查找，并删除
	    vector<CWorkerThread*>::iterator pos;
		pos = find(m_IdleList.begin(),m_IdleList.end(), removeThread);
		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* jobArgs)
{
    assert(job!=NULL);

    //如果已经达到了最大线程数，则等待
    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*  idleThread = GetIdleThread();
	if(idleThread !=NULL)
    {
	    idleThread->m_WorkMutex.Lock();
		//移动到忙碌队列
	    MoveToBusyList(idleThread);
	    idleThread->SetThreadPool(this);
		//任务调用线程进行执行
	    job->SetWorkThread(idleThread);
	    printf("Job is set to thread %d /n",idlethr->GetThreadID());
		idleThread->SetJob(job,jobArgs);
    }
}
在CThreadPool中存在两个链表，一个是空闲链表，一个是忙碌链表。Idle链表中存放所有的空闲进程，当线程执行任务时候，其状态变为忙碌状态，同时从空闲链表中删除，并移至忙碌链表中。
在CThreadPool的构造函数中，我们将创建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，因此我们必须对线程的创建区别对待。因此，如果创建后总数不超过m_MaxNum，则创建后的线程为m_InitNum；如果超过了，则只创建(
 m_MaxNum-当前线程总数 )个。
(3) 调用GetIdleThread方法查找空闲线程。如果当前没有空闲线程，则挂起；否则将任务指派给该线程，同时将其移入忙碌队列。
当线程执行完毕后，其会调用MoveToIdleList方法移入空闲链表中，其中还调用m_IdleCond.Signal()方法，唤醒GetIdleThread()中可能阻塞的线程。
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;					//线程分离
    bool m_CreateSuspended;			//创建之后即挂起
    char* m_ThreadName;				//线程名称
    ThreadState m_ThreadState;      //线程状态

protected:
	//设置错误码
    void SetErrcode(int errcode)
	{
		m_ErrCode = errcode;
	}
    static void* ThreadFunction(void* args);

public:
    CThread();
    CThread(bool createSuspended, bool detach);

    virtual ~CThread();
	//定义接口
    virtual void Run(void) = 0;

	//设置或获取线程的状态
    void SetThreadState(ThreadState state)
	{
		m_ThreadState = state;
	}
    ThreadState GetThreadState(void)
	{
		return m_ThreadState;
	} 

	//终止线程
    bool Terminate();
	//执行线程
    bool Start();        
    void Exit();
    bool Wakeup();
   
	int GetLastError(void)
	{ 
		return m_ErrCode;
	}
    
	//获取或设置线程名称
	void SetThreadName(char* thrname)
	{
		strcpy(m_ThreadName,thrname);
	}
    char* GetThreadName()
	{
		return m_ThreadName;
	}

	//获取线程ID
    int GetThreadID()
	{
		return m_ThreadID;
	}
 
	//获取或设置优先级
    bool SetPriority(int priority);
    int GetPriority();
    int GetConcurrency();
    void SetConcurrency(int num);
    bool Detach();
    bool Join();
    bool Yield(void);
    int Self(void);
};
线程的状态可以分为四种，空闲、忙碌、挂起、终止(包括正常退出和非正常退出)。由于目前Linux线程库不支持挂起操作，因此，我们的此处的挂起操作类似于暂停。如果线程创建后不想立即执行任务，那么我们可以将其“暂停”，如果需要运行，则唤醒。有一点必须注意的是，一旦线程开始执行任务，将不能被挂起，其将一直执行任务至完毕。

线程类的相关操作均十分简单。线程的执行入口是从Start()函数开始，其将调用函数ThreadFunction，ThreadFunction再调用实际的Run函数，执行实际的任务。
 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;

public:
    CWorkerThread();
    virtual ~CWorkerThread();
    
	CCondition m_JobCond;
    CThreadMutex m_WorkMutex;

    void Run();

	//设置或获取任务
    void SetJob(CJob* job,void* jobdata);
    CJob* GetJob()
	{
		return m_Job;
	}
    
	//设置或获取线程所在的线程池
	void SetThreadPool(CThreadPool* thrpool);
    CThreadPool* GetThreadPool()
	{
		return m_ThreadPool;
	}
};

实现文件：

orkerThread::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_ThreadPool->GetInitNum());
		}
		m_WorkMutex.Unlock();
    }
}

//设置要执行的任务
void CWorkerThread::SetJob(CJob* job, void* jobArgs)
{
    m_VarMutex.Lock();
    m_Job = job;
    m_JobData = jobArgs;
    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;					//任务编号
    char * m_JobName;				//任务名称
    CThread * m_pWorkThread;		//The thread associated with the job

public:
    CJob();
    virtual ~CJob();
    
	//设置或获取任务编号
    int GetJobNo(void)
	{ 
		return m_JobNo; 
	}
    void SetJobNo(int jobno)
	{ 
		m_JobNo = jobno;
	}

	//设置或获取任务名称
    char* GetJobName(void) const 
	{ 
		return m_JobName; 
	}
    void SetJobName(char* jobname);

	//获取或设置工作线程
    CThread * GetWorkThread()
	{ 
		return m_pWorkThread; 
	}
    void SetWorkThread(CThread * pWorkThread)
	{
        m_pWorkThread = pWorkThread;
    }

	//指定Run接口
    virtual void Run ( void *ptr ) = 0;
};

实现文件：

CJob::CJob():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去执行。下面我们给出一个简单的示例程序
CXJob：

class CXJob : public CJob  
{
public:
    CXJob()
	{
		i=0;
	}

    ~CXJob()
	{}

    void Run(void* jobArgs)    
	{
        printf("The Job comes from CXJOB/n");
        sleep(2);
    }
};


CYJob：

class CYJob : public CJob  
{
public:
public:
    CYJob()
	{
		i=0;
	}

    ~CYJob()
	{}

    void Run(void* jobdata)    
	{
        printf("The Job comes from CYJob/n");
    }
};
main.cpp文件：

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下多线程的开发工作。该线程池的进一步完善开发工作还在进行中，希望能够得到你的建议和支持。