简单线程池类

来源：互联网发布：刘胜军知乎编辑：程序博客网时间：2024/06/07 06:18
简单练习了一下代码，简单实现了一下线程池类，增加对线程的理解和掌控。以后有时间再好好完善下，现在和大家分享下：
[cpp] view plaincopy
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <time.h>  
#include <string.h>  
#include <math.h>  
#include <sys/types.h>  
#include <stdlib.h>  
#include <sys/ipc.h>  
#include <sys/shm.h>  
#include <pthread.h>  
#include <assert.h>  
#include <vector>  
#include<iostream>  
  
using namespace std;  
  
typedef struct worker  
{  
    void* (*process)(void* arg);  
    void* arg;  
    pthread_t threadid;  
  
} worker_thread;  
  
  
  
typedef vector<worker_thread>::iterator TASK_ITERTOR;  
  
class ThreadPool  
{  
public:  
  ThreadPool(void);  
  ~ThreadPool(void);  
  
  
  static ThreadPool& Instance(){static ThreadPool single; return single;}  
  
  bool Init(int number);  
  
  bool add(void *(*process) (void *arg), void *arg);  
  
  bool clear();  
  
  bool GetTask(int index);  
  
  void *thread_run();  
  ///方法成员  
public:  
    
  ///数据成员  
private:  
  
   pthread_mutex_t m_lock;     //线程锁  
   pthread_cond_t  m_ready;   //条件变量  
   vector<worker_thread> m_threadPool; //线程容器  
   int isDestory;       //是否销毁  
   int m_max_thread_num; //活动的最大现场数  
  
   int cur_thread_index; //当前现场的索引  
  
   pthread_t* threadid;  
  
   TASK_ITERTOR m_iter;  
};  
  
  
  
static void *run(void *arg)  
{  
    ThreadPool* p = (ThreadPool*)arg;  
  
    p->thread_run();  
  
}  
  
  
ThreadPool::ThreadPool(void)  
{  
   m_max_thread_num = 0;  
   cur_thread_index = 0;  
   isDestory = 0;  
}  
  
ThreadPool::~ThreadPool()  
{  
  
}  
  
bool ThreadPool::Init(int number)  
{  
  
   m_max_thread_num = number;  
  
   pthread_mutex_init(&m_lock,NULL);  
   pthread_cond_init(&m_ready,NULL);  
  
   cur_thread_index = 0;  
  
   threadid = new pthread_t[number];  
   
   for (int thread_loop = 0;thread_loop < number;thread_loop++)  
   {  
       //printf("initital,create thread no.=%0x\n",threadid[thread_loop]);  
       pthread_create(&threadid[thread_loop],NULL,run,(void*)(this));  
   }  
  
     
   return true;  
  
}  
  
bool ThreadPool::GetTask(int index)  
{     
     m_iter  = m_threadPool.begin();  
     for (int i = 0;i< index;i++)  
     {  
        m_iter++;  
     }  
}  
  
bool ThreadPool::add(void *(* process)(void * arg),void * arg)  
{  
   worker_thread work;  
  
   work.arg = arg;  
   work.process = process;  
  
   pthread_mutex_lock(&m_lock);  
  
   m_threadPool.push_back(work);  
  
   //ThreadPool::Instance().GetHead(cur_thread_index);  
   cur_thread_index++;  
    
   pthread_mutex_unlock(&m_lock);  
  
   pthread_cond_signal(&m_ready);  
  
   //printf("task size=%d\n",m_threadPool.size());  
   return true;  
}  
  
  
bool ThreadPool::clear()  
{  
   if (isDestory)  
   {  
       return true;  
   }  
  
   isDestory = 1;  
  
   pthread_cond_broadcast(&m_ready);  
  
   for (int i = 0; i < m_max_thread_num; i++)  
         pthread_join (threadid[i], NULL);  
      
   delete []threadid;  
  
   pthread_mutex_destroy(&m_lock);  
   pthread_cond_destroy(&m_ready);  
  
   m_threadPool.clear();  
}  
  
void * ThreadPool::thread_run()  
{  
     
   printf("%0x thread is startting\n",pthread_self());  
  
    
   int li_loop = 0;  
     
   while(1)  
   {  
       pthread_mutex_lock(&m_lock);  
       //int* cur_index = (int*)arg;  
       //printf("cur_thread_index=%d\n",cur_thread_index);  
       while(cur_thread_index== 0 && !isDestory)  
       {  
            printf ("thread %0x is waiting\n", pthread_self ());  
            pthread_cond_wait(&m_ready, &m_lock);  
       }  
  
        if (isDestory)  
       {  
            
           pthread_mutex_unlock (&m_lock);  
           printf ("thread %0x will exit\n", pthread_self ());  
           pthread_exit (NULL);  
       }  
          
  
       printf ("thread %0x is starting to work\n", pthread_self ());  
  
        
       cur_thread_index--;  
  
           
         worker_thread* work =&(*m_iter);  
  
         if (work != NULL)  
         {  
             (*(work->process))(m_iter->arg);  
  
             m_iter++;  
         }  
  
          
  
    /* for (;iter != m_threadPool.end();++iter) 
     { 
         worker_thread* work =&(*iter); 
 
         (*(work->process))(iter->arg); 
 
         li_loop++; 
 
         if (li_loop == m_max_thread_num) 
         { 
              li_loop = 0; 
               
         } 
     } */  
        
           
         pthread_mutex_unlock(&m_lock);  
  
           
           
  
    }  
  
    
}  
  
void * task_run (void *arg)  
{      
     int* task_no = (int*)(arg);  
     printf (" task %d is on working that threadid is %0x,\n", *task_no,pthread_self ());  
     sleep (2);/*休息一秒，延长任务的执行时间*/  
    return NULL;  
}  
  
  
char *GetCurrentTime(char *azp_CurrentTime)  
{  
  time_t lt_now_time;  
  struct tm *local_time;  
  time(<_now_time);  
  local_time=localtime(<_now_time);  
  
  sprintf(azp_CurrentTime,"%d-%02d-%02d %02d:%02d:%02d",local_time->tm_year+1900,  
    local_time->tm_mon+1,local_time->tm_mday,local_time->tm_hour,local_time->tm_min,local_time->tm_sec);  
  return(azp_CurrentTime);  
}  
  
  
int DateTimeCmp(char *azp_DateTime1,    /*时间1*/  
                char *azp_DateTime2,    /*时间2*/  
                long *alp_Duration      /*结果整形指针*/  
         )  
{  
  struct tm ls_DateTime1,ls_DateTime2;  
  time_t    lt_DateTime1,lt_DateTime2;  
  long    ll_Duration;  
  
  memset((void *) &ls_DateTime1, 0, sizeof(struct tm));  
  memset((void *) &ls_DateTime2, 0, sizeof(struct tm));  
  
  /*转换为tm结构变量*/  
  strptime( azp_DateTime1,"%Y-%m-%d %T", &ls_DateTime1 );  
  strptime( azp_DateTime2,"%Y-%m-%d %T", &ls_DateTime2 );  
  
  /*将结果转换为字串*/  
  if  (( lt_DateTime1 = mktime( &ls_DateTime1 )) == (time_t)-1 )  
  {  
    return( -1 );  
  }  
  if  (( lt_DateTime2 = mktime( &ls_DateTime2 )) == (time_t)-1 )  
  {  
    return( -1 );  
  }  
    
  /*将比较结果写入目标缓冲*/  
  *alp_Duration = (long)difftime( lt_DateTime1,lt_DateTime2 );  
    
  return( 0 );  
}  
  
  
int main()  
{  
  
    char curtime[20]={0};  
    char lasttime[20]={0};  
    long li_dur = 0;  
    ThreadPool::Instance().Init(3);  
     
    int i;  
  
    int *workingnum = (int *) malloc (sizeof (int) * 10);  
  
    GetCurrentTime(curtime);  
    //printf("curtime=%s\n",curtime);  
    while(1)  
    {     
        GetCurrentTime(lasttime);  
  
          
        DateTimeCmp(lasttime,curtime,&li_dur);  
  
        //printf("li_dur=%d\n",li_dur);  
        if (li_dur > 10)  
        {  
            for (i = 0; i < 10; i++)  
            {  
                workingnum[i] = i;  
                ThreadPool::Instance().add(task_run, &workingnum[i]);   
                ThreadPool::Instance().GetTask(i);  
                sleep(1);     
            }  
  
            strcpy(curtime,lasttime);  
        }  
    }  
  
      
  
    /*等待所有任务完成*/  
     sleep (10);  
    /*销毁线程池*/  
     //ThreadPool::Instance().clear();  
  
  
     free (workingnum);  
    return 0;  
  
}  