简单线程池类

简单练习了一下代码，简单实现了一下线程池类，增加对线程的理解和掌控。以后有时间再好好完善下，现在和大家分享下：

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

}