class CThreadManage
{
private:
  CThreadPool*  m_Pool;
  int     m_NumOfThread;
 
protected:
 
public:
  CThreadManage();
  CThreadManage(int num);
  virtual ~CThreadManage();
 
  void   SetParallelNum(int num);  
  void  Run(CJob* job,void* jobdata);
  void  TerminateAll(void);
};

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();
}

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);
};

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);
};
 
 
 
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 %d\n",thr->GetThreadID());
 
  m_IdleMutex.Unlock();
 
  return thr;
 
  }
 
  m_IdleMutex.Unlock();
 
  return NULL; 
}
  

//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::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);
 
  }
 
}

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
 
  }

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

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;
 
}; 

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();
 
} 

struct TC_ThreadPool_Exception : public TC_Exception
{
  TC_ThreadPool_Exception(const string &buffer) : TC_Exception(buffer){};
  TC_ThreadPool_Exception(const string &buffer, int err) : TC_Exception(buffer, err){};
  ~TC_ThreadPool_Exception () throw (){};
};


/**
 * @brief 用通線程池類, 與tc_functor, tc_functorwrapper配合使用.
 * 
 * 使用方式說明:
 * 1 采用tc_functorwrapper封裝一個調(diào)用
 * 2 用tc_threadpool對調(diào)用進(jìn)行執(zhí)行
 * 具體示例代碼請參見:test/test_tc_thread_pool.cpp
 */

/**線程池本身繼承自鎖，可以幫助鎖定**/
class TC_ThreadPool : public TC_ThreadLock
{
public:

  /**
   * @brief 構(gòu)造函數(shù)
   *
   */
  TC_ThreadPool ();

  /**
   * @brief 析構(gòu), 會停止所有線程
   */
  ~TC_ThreadPool ();

  /**
   * @brief 初始化.
   * 
   * @param num 工作線程個數(shù)
   */
  void init(size_t num);

  /**
   * @brief 獲取線程個數(shù).
   *
   * @return size_t 線程個數(shù)
   */
  size_t getThreadNum()  { Lock sync(* this); return _jobthread. size(); }

  /**
   * @brief 獲取線程池的任務(wù)數(shù)( exec添加進(jìn)去的).
   *
   * @return size_t 線程池的任務(wù)數(shù)
   */
  size_t getJobNum()   { return _jobqueue. size(); }

  /**
   * @brief 停止所有線程
   */
  void stop();

  /**
   * @brief 啟動所有線程
   */
  void start();

  /**
   * @brief 啟動所有線程并, 執(zhí)行初始化對象.
   * 
   * @param ParentFunctor
   * @param tf
   */
  template<class ParentFunctor>
  void start(const TC_FunctorWrapper< ParentFunctor> &tf)
  {
    for(size_t i = 0; i < _jobthread .size(); i++)
    {
      _startqueue. push_back(new TC_FunctorWrapper<ParentFunctor >(tf));
    }

    start();
  }

  /**
   * @brief 添加對象到線程池執(zhí)行，該函數(shù)馬上返回，
   *   線程池的線程執(zhí)行對象
   */
  template<class ParentFunctor>
   void exec(const TC_FunctorWrapper< ParentFunctor> &tf)
  {
    _jobqueue.push_back(new TC_FunctorWrapper<ParentFunctor >(tf));
  }

  /**
   * @brief 等待所有工作全部結(jié)束(隊(duì)列無任務(wù), 無空閑線程).
   *
   * @param millsecond 等待的時間( ms), -1:永遠(yuǎn)等待
   * @return      true, 所有工作都處理完畢
   *            false,超時退出
   */
  bool waitForAllDone(int millsecond = -1);

public:

  /**
   * @brief 線程數(shù)據(jù)基類,所有線程的私有數(shù)據(jù)繼承于該類
   */
  class ThreadData
  {
  public:
    /**
     * @brief 構(gòu)造
     */
    ThreadData(){};
    /**
     * @brief 析夠
     */
    virtual ~ThreadData(){};

    /**
      * @brief 生成數(shù)據(jù).
      * 
      * @ param T
     * @return ThreadData*
     */
    template<typename T>
    static T* makeThreadData()
    {
      return new T;
    }
  };

  /**
   * @brief 設(shè)置線程數(shù)據(jù).
   * 
   * @param p 線程數(shù)據(jù)
   */
  static void setThreadData(ThreadData *p);

  /**
   * @brief 獲取線程數(shù)據(jù).
   *
   * @return ThreadData* 線程數(shù)據(jù)
   */
  static ThreadData* getThreadData();

  /**
   * @brief 設(shè)置線程數(shù)據(jù), key需要自己維護(hù).
   * 
   * @param pkey 線程私有數(shù)據(jù)key
   * @param p  線程指針
   */
  static void setThreadData(pthread_key_t pkey, ThreadData *p);

  /**
   * @brief 獲取線程數(shù)據(jù), key需要自己維護(hù).
   * 
   * @param pkey 線程私有數(shù)據(jù)key
   * @return   指向線程的ThreadData*指針
   */
  static ThreadData* getThreadData(pthread_key_t pkey);

protected:

  /**
   * @brief 釋放資源.
   * 
   * @param p
   */
  static void destructor(void *p);

  /**
   * @brief 初始化key
   */
  class KeyInitialize
  {
  public:
    /**
     * @brief 初始化key
     */
    KeyInitialize()
    {
      int ret = pthread_key_create(&TC_ThreadPool::g_key, TC_ThreadPool::destructor);
      if(ret != 0)
      {
        throw TC_ThreadPool_Exception("[TC_ThreadPool::KeyInitialize] pthread_key_create error", ret);
      }
    }

    /**
     * @brief 釋放key
     */
    ~KeyInitialize()
    {
      pthread_key_delete(TC_ThreadPool::g_key);
    }
  };

  /**
   * @brief 初始化key的控制
   */
  static KeyInitialize g_key_initialize;

  /**
   * @brief 數(shù)據(jù)key
   */
  static pthread_key_t g_key;

protected:
  /**
   * @brief 線程池中的工作線程
   */
  class ThreadWorker : public TC_Thread
  {
  public:
    /**
      * @brief 工作線程構(gòu)造函數(shù).
      * 
     * @ param tpool
     */
    ThreadWorker(TC_ThreadPool *tpool);

    /**
     * @brief 通知工作線程結(jié)束
     */
    void terminate();

  protected:
    /**
     * @brief 運(yùn)行
     */
    virtual void run();

  protected:
    /**
     * 線程池指針
     */
    TC_ThreadPool  * _tpool;

    /**
     * 是否結(jié)束線程
     */
    bool      _bTerminate;
  };

protected:

  /**
   * @brief 清除
   */
  void clear();

  /**
   * @brief 獲取任務(wù), 如果沒有任務(wù), 則為NULL.
   *
   * @return TC_FunctorWrapperInterface*
   */
  TC_FunctorWrapperInterface * get(ThreadWorker *ptw);

  /**
   * @brief 獲取啟動任務(wù).
   *
   * @return TC_FunctorWrapperInterface*
   */
  TC_FunctorWrapperInterface * get();

  /**
   * @brief 空閑了一個線程.
   * 
   * @param ptw
   */
  void idle(ThreadWorker *ptw);

  /**
   * @brief 通知等待在任務(wù)隊(duì)列上的工作線程醒來
   */
  void notifyT();

  /**
   * @brief 是否處理結(jié)束.
   *
   * @return bool
   */
  bool finish();

  /**
   * @brief 線程退出時調(diào)用
   */
  void exit();

  friend class ThreadWorker;
protected:

  /**
   * 任務(wù)隊(duì)列
   */
  TC_ThreadQueue< TC_FunctorWrapperInterface*> _jobqueue;

  /**
   * 啟動任務(wù)
   */
  TC_ThreadQueue< TC_FunctorWrapperInterface*> _startqueue;

  /**
   * 工作線程
   */
  std::vector<ThreadWorker *>         _jobthread;

  /**
   * 繁忙線程
   */
  std::set<ThreadWorker *>           _busthread;

  /**
   * 任務(wù)隊(duì)列的鎖
   */
  TC_ThreadLock                _tmutex;

   /**
   * 是否所有任務(wù)都執(zhí)行完畢
   */
   bool                    _bAllDone;
};

TC_ThreadPool ::ThreadWorker::ThreadWorker(TC_ThreadPool *tpool)
: _tpool (tpool)
, _bTerminate ( false)
{
}

void TC_ThreadPool ::ThreadWorker::terminate()
{
  _bTerminate = true;
  _tpool->notifyT();
}

void TC_ThreadPool ::ThreadWorker::run()
{
  //調(diào)用初始化部分
  TC_FunctorWrapperInterface *pst = _tpool->get();
  if(pst)
  {
    try
    {
      (*pst)();
    }
    catch ( ... )
    {
    }
    delete pst;
    pst = NULL;
  }

  //調(diào)用處理部分
  while (! _bTerminate)
  {
    TC_FunctorWrapperInterface *pfw = _tpool->get( this);
    if(pfw != NULL)
    {
      auto_ptr< TC_FunctorWrapperInterface> apfw(pfw);

      try
      {
        (*pfw)();
      }
      catch ( ... )
      {
      }

      _tpool->idle( this);
    }
  }

  //結(jié)束
  _tpool->exit();
}

每個工作線程在剛開始時都會執(zhí)行一下初始化操作，并進(jìn)入一個無限循環(huán)的部分//調(diào)用處理部分
  while (! _bTerminate)
  {
    TC_FunctorWrapperInterface *pfw = _tpool->get( this);
    if(pfw != NULL)
    {
      auto_ptr< TC_FunctorWrapperInterface> apfw(pfw);

      try
      {
        (*pfw)();
      }
      catch ( ... )
      {
      }

      _tpool->idle( this);
    }
  }

TC_FunctorWrapperInterface *TC_ThreadPool:: get(ThreadWorker *ptw)
{

  TC_FunctorWrapperInterface *pFunctorWrapper = NULL;
  if(! _jobqueue. pop_front(pFunctorWrapper, 1000))
  {
    return NULL;
  }

   {
      Lock sync( _tmutex);
     _busthread. insert(ptw);
  }
  return pFunctorWrapper;
}

void TC_ThreadPool:: idle(ThreadWorker *ptw)
{
  Lock sync( _tmutex);
  _busthread. erase(ptw);

  //無繁忙線程, 通知等待在線程池結(jié)束的線程醒過來
  if( _busthread. empty())
  {
    _bAllDone = true;
    _tmutex.notifyAll();
  }
}

  if( _busthread. empty())
  {
    _bAllDone = true;
    _tmutex.notifyAll();
  }

bool TC_ThreadPool:: waitForAllDone( int millsecond)
{
  Lock sync( _tmutex);

start1:
  //任務(wù)隊(duì)列和繁忙線程都是空的
  if (finish())
  {
    return true;
  }

  //永遠(yuǎn)等待
  if(millsecond < 0)
  {
    _tmutex.timedWait(1000);
    goto start1;
  }

  int64_t iNow = TC_Common:: now2ms();
  int m    = millsecond;
start2:

  bool b = _tmutex.timedWait(millsecond);
  //完成處理了
  if(finish())
  {
    return true;
  }

  if(!b)
  {
    return false;
  }

  millsecond = max((int64_t )0, m - (TC_Common ::now2ms() - iNow));
  goto start2;

  return false;
}

_tmutex.timedWait(millsecond)方法喚醒。反復(fù)判斷是否所有的工作是否完成：

bool TC_ThreadPool:: finish()
{
  return _startqueue. empty() && _jobqueue .empty() && _busthread. empty() && _bAllDone;
}

TC_ThreadPool ::KeyInitialize TC_ThreadPool::g_key_initialize;
pthread_key_t TC_ThreadPool::g_key ;

void TC_ThreadPool::destructor( void *p)
{
  ThreadData *ttd = ( ThreadData*)p;
  if(ttd)
  {
    delete ttd;
  }
}

void TC_ThreadPool::exit()
{
  TC_ThreadPool:: ThreadData *p = getThreadData();
  if(p)
  {
    delete p;
    int ret = pthread_setspecific( g_key, NULL );
    if(ret != 0)
    {
      throw TC_ThreadPool_Exception ("[TC_ThreadPool::setThreadData] pthread_setspecific error", ret);
    }
  }

  _jobqueue. clear();
}

void TC_ThreadPool::setThreadData( TC_ThreadPool:: ThreadData *p)
{
  TC_ThreadPool:: ThreadData *pOld = getThreadData();
  if(pOld != NULL && pOld != p)
  {
    delete pOld;
  }

  int ret = pthread_setspecific( g_key, ( void *)p);
  if(ret != 0)
  {
    throw TC_ThreadPool_Exception ("[TC_ThreadPool::setThreadData] pthread_setspecific error", ret);
  }
}

TC_ThreadPool ::ThreadData * TC_ThreadPool::getThreadData ()
{
  return ( ThreadData *) pthread_getspecific( g_key);
}

void TC_ThreadPool::setThreadData( pthread_key_t pkey, ThreadData *p)
{
  TC_ThreadPool:: ThreadData *pOld = getThreadData(pkey);
  if(pOld != NULL && pOld != p)
  {
    delete pOld;
  }

  int ret = pthread_setspecific(pkey, ( void *)p);
  if(ret != 0)
  {
    throw TC_ThreadPool_Exception ("[TC_ThreadPool::setThreadData] pthread_setspecific error", ret);
  }
}

TC_ThreadPool ::ThreadData * TC_ThreadPool::getThreadData( pthread_key_t pkey)
{
  return ( ThreadData *) pthread_getspecific(pkey);
}

TC_ThreadPool::TC_ThreadPool()
: _bAllDone ( true)
{
}

TC_ThreadPool::~TC_ThreadPool()
{
  stop();
  clear();
}

void TC_ThreadPool::clear()
{
  std::vector< ThreadWorker *>::iterator it = _jobthread. begin();
  while(it != _jobthread. end())
  {
    delete (*it);
    ++it;
  }

  _jobthread. clear();
  _busthread. clear();
}

void TC_ThreadPool::init( size_t num)
{
  stop();

  Lock sync(* this);

  clear();

  for( size_t i = 0; i < num; i++)
  {
    _jobthread. push_back( new ThreadWorker( this));
  }
}

void TC_ThreadPool::stop()
{
  Lock sync(* this);

  std::vector< ThreadWorker *>::iterator it = _jobthread. begin();
  while(it != _jobthread. end())
  {
    if ((*it)-> isAlive())
    {
      (*it)-> terminate();
      (*it)-> getThreadControl().join ();
    }
    ++it;
  }
  _bAllDone = true;
}

void TC_ThreadPool::start()
{
  Lock sync(* this);

  std::vector< ThreadWorker *>::iterator it = _jobthread. begin();
  while(it != _jobthread. end())
  {
    (*it)-> start();
    ++it;
  }
  _bAllDone = false;
}

bool TC_ThreadPool:: finish()
{
  return _startqueue. empty() && _jobqueue .empty() && _busthread. empty() && _bAllDone;
}

bool TC_ThreadPool::waitForAllDone( int millsecond)
{
  Lock sync( _tmutex);

start1:
  //任務(wù)隊(duì)列和繁忙線程都是空的
  if (finish ())
  {
    return true;
  }

  //永遠(yuǎn)等待
  if(millsecond < 0)
  {
    _tmutex.timedWait(1000);
    goto start1;
  }

  int64_t iNow = TC_Common:: now2ms();
  int m    = millsecond;
start2:

  bool b = _tmutex.timedWait(millsecond);
  //完成處理了
  if(finish ())
  {
    return true;
  }

  if(!b)
  {
    return false;
  }

  millsecond = max((int64_t )0, m - (TC_Common ::now2ms() - iNow));
  goto start2;

  return false;
}

TC_FunctorWrapperInterface *TC_ThreadPool::get( ThreadWorker *ptw)
{

  TC_FunctorWrapperInterface *pFunctorWrapper = NULL;
  if(! _jobqueue. pop_front(pFunctorWrapper, 1000))
  {
    return NULL;
  }

   {
      Lock sync( _tmutex);
     _busthread. insert(ptw);
  }
  return pFunctorWrapper;
}

TC_FunctorWrapperInterface *TC_ThreadPool::get()
{
  TC_FunctorWrapperInterface *pFunctorWrapper = NULL;
  if(! _startqueue. pop_front(pFunctorWrapper))
  {
    return NULL;
  }

  return pFunctorWrapper;
}

void TC_ThreadPool::idle( ThreadWorker *ptw)
{
  Lock sync( _tmutex);
  _busthread. erase(ptw);

  //無繁忙線程, 通知等待在線程池結(jié)束的線程醒過來
  if( _busthread. empty())
  {
      _bAllDone = true;
    _tmutex.notifyAll();
  }
}

void TC_ThreadPool::notifyT()
{
  _jobqueue. notifyT();
}

線程池使用后記
線程池適合場合
事 實(shí)上，線程池并不是萬能的。它有其特定的使用場合。線程池致力于減少線程本身的開銷對應(yīng)用所產(chǎn)生的影響，這是有前提的，前提就是線程本身開銷與線程執(zhí)行任 務(wù)相比不可忽略。如果線程本身的開銷相對于線程任務(wù)執(zhí)行開銷而言是可以忽略不計(jì)的，那么此時線程池所帶來的好處是不明顯的，比如對于FTP服務(wù)器以及Telnet服務(wù)器，通常傳送文件的時間較長，開銷較大，那么此時，我們采用線程池未必是理想的方法，我們可以選擇“即時創(chuàng)建，即時銷毀”的策略。
 總之線程池通常適合下面的幾個場合：
 
(1)  單位時間內(nèi)處理任務(wù)頻繁而且任務(wù)處理時間短
 
(2)  對實(shí)時性要求較高。如果接受到任務(wù)后在創(chuàng)建線程，可能滿足不了實(shí)時要求，因此必須采用線程池進(jìn)行預(yù)創(chuàng)建。
 
(3)  必須經(jīng)常面對高突發(fā)性事件，比如Web服務(wù)器，如果有足球轉(zhuǎn)播，則服務(wù)器將產(chǎn)生巨大的沖擊。此時如果采取傳統(tǒng)方法，則必須不停的大量產(chǎn)生線程，銷毀線程。此時采用動態(tài)線程池可以避免這種情況的發(fā)生。