简单练习了一下代码,简单实现了一下线程池类,增加对线程的理解和掌控。以后有时间再好好完善下,现在和大家分享下:
#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;
}