#ifndef THREAD_POOL #define THREAD_POOL #include "ace/Task.h" #include "ace/Thread_Mutex.h" #include "ace/Thread_Semaphore.h" class thread_pool : public ACE_Task<ACE_MT_SYNCH> { public: thread_pool (); ~thread_pool (); // begin the initial threads and waiting for request int start_pool ( int minnum =5, // min number of thread int maxnum =100, // max number of thread int waitsize =1024, // request queue length int parsize =1024); // your parameter size // pending request in work queue int wait_cnt (); // add one task to thread pool int add_task (void*arg, int size); // user defined work thread function virtual int service_func (void* arg); // overide base class function for thread pool logical virtual int svc (void); // not use virtual int handle_timeout (const ACE_Time_Value &tv, constvoid*arg); private: int minnum_, maxnum_; int waitsize_, parsize_; // ACE_Recursive_Thread_Mutex free_thread_cnt__mutex_; ACE_Thread_Semaphore *pfree_thread_; // for free thread count long thread_flags_; // ace thread create flag }; #endif /**//* THREAD_POOL */
thread_pool.cpp实现文件:
#include "thread_pool.h" #define THREAD_POOL_DONOT_ACQUIRE 0x1001// do not aquire again in new added thread thread_pool::thread_pool () { thread_flags_ = THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED; pfree_thread_ = NULL; } thread_pool::~thread_pool () { if (pfree_thread_) delete pfree_thread_; } int thread_pool::wait_cnt () { returnthis->msg_queue()->message_count (); } int thread_pool::handle_timeout (const ACE_Time_Value &tv, constvoid*arg) { return0; } int thread_pool::start_pool ( int minnum, int maxnum, int waitsize, int parsize) { minnum_ = minnum; maxnum_ = maxnum; waitsize_ = waitsize; parsize_ = parsize; this->msg_queue()->high_water_mark (waitsize * parsize); pfree_thread_ =new ACE_Thread_Semaphore (minnum); int ret =this->activate (thread_flags_, minnum); return ret; } int thread_pool::add_task (void*arg, int size) { ACE_Message_Block *mb =new ACE_Message_Block (parsize_); // test free threads condition if (pfree_thread_->tryacquire () ==-1) { // acquire one free thread to do work printf ("free thread used up\n"); if (this->thr_count () < maxnum_) { this->activate (thread_flags_, 1, 1); printf ("new thread release\n"); pfree_thread_->release (); printf ("new one thread, now %d\n", this->thr_count ()); }else{ printf ("can't new more threads, queue len %d\n", wait_cnt () +1); } }else{ // pfree_thread_->release (); // restore cnt, let svc function do acquire work printf ("new task acquire\n"); mb->set_flags (THREAD_POOL_DONOT_ACQUIRE); } // create msg printf ("add msg\n"); memcpy (mb->wr_ptr (), (char*) arg, size); this->putq (mb); return0; } int thread_pool::service_func (void* arg) { sleep (1); printf ("finished task %d in thread %02X\n", *(int*) arg, (int)ACE_Thread::self ()); return0; } int thread_pool::svc (void) { printf ("thread started\n"); while (1) { ACE_Message_Block *b =0; ACE_Time_Value wait = ACE_OS::gettimeofday (); wait.sec (wait.sec () +10); // timeout in 10 secs to test if more tasks need to do or we'll exit if (this->getq (b, &wait) <0) { if (this->thr_count () > minnum_) { printf ("over task acquire\n"); pfree_thread_->acquire (); printf ("delete one thread, now %d\n", this->thr_count ()-1); return0; }else continue; // I'm the one of last min number of threads } if (b->flags () & THREAD_POOL_DONOT_ACQUIRE ==0) { printf ("queue task acquire\n"); pfree_thread_->acquire (); // I'll use one free thread } else printf ("no need to acquire\n"); this->service_func ((void*)b->rd_ptr()); printf ("finished release\n"); b->release(); pfree_thread_->release (); // added one free thread } return0; } #ifdef THREAD_POOL_UNIT_TEST int main (int argc, int** argv) { printf ("begin test:\n"); /**//* ACE_Thread_Semaphore* s = new ACE_Thread_Semaphore (0); s->release (3); s->acquire (); s->acquire (); s->acquire (); printf ("ok"); return 0; */ thread_pool t; t.start_pool (10, 100); for (int i=0; i<200; i++) { t.add_task (&i, sizeof(i)); if (i %20==0) sleep (1); } sleep (1000); printf ("end test:\n"); return0; } #endif