linux多少线程池,Linux线程池

/*

小规模的Linux线程池

written by luoxiongwei

E-mail:luo6620378li@qq.com

Welcom to report bugs!

下一步计划给工作队列中的任务添加优先级

实现一个优先队列。

*/

#ifndef __THREADPOOLS

#define __THREADPOOLS

#include

#include

#include

#include

#include

#include

#include

using std::vector;

struct task//队列中的任务结点

{

void (*handler)(void *);//任务函数

void * data;//任务数据

//int prority;//任务优先级

};

struct work_queue_t//工作队列

{

struct work_queue_t * next ;

struct work_queue_t * head ;

struct work_queue_t * tail ;

struct task * elment ;

};

//工作队列操作

work_queue_t * init_work_queue();//初始化工作队列

void destory_work_queue();//销毁工作队列

work_queue_t * remove_task();//取队首任务

int add_tast(task * new_task);//在工作队列尾部添加任务

bool empty();

//线程池资源

void *thread_rounter(void *);//线程执行函数

struct work_queue_t * work_queue=NULL;//工作队列

int work_count=0;//工作队列中的元素个数

vector threads;//记录所有线程的id

pthread_cond_t pool_cond;//唤醒相应线程开始工作

pthread_mutex_t queue_lock;//保护工作队列,以及池中的互斥资源

int idles;//空闲线程数目

int busy;//正在执行任务的线程数目

int max_thread;//池中维持的最大线程数目

bool to_exit;//销毁线程池标志

bool validate;//线程池是否可用

//线程池操作,提供给用户操作的四个函数

void thread_pool(int init_threads_num);//建立线程池

void destroy_thread_pool();//销毁线程池

/*组装任务处理函数和处理函数参数，注意一旦该任务完成之后，

数据将会被系统释放掉，所以下一次向线程池加入任务时线程池linux，

请重新组装。请保证处理函数是线程可重入的。

*/

task * prod_task(void (*handler)(void *), void * data);

int exec_task(task * new_task);//留给用户的调用接口

#endif

//示例的工作函数

void task1(void *arg);

int main()

{

//现在测试了池中有10个线程，12个任务。

//任务参数

char *ptr1="I am task one\n";

char *ptr2="I am task two\n";

char *ptr3="I am task three\n";

char *ptr4="I am task four\n";

char *ptr5="I am task five\n";

char *ptr6="I am task six\n";

char *ptr7="I am task seven\n";

char *ptr8="I am task eight\n";

char *ptr9="I am task nine\n";

char *ptr10="I am task ten\n";

char *ptr11="I am task eleven\n";

char *ptr12="I am task twltle\n";

//组装任务

task * task_p1=prod_task(task1,ptr1);

task * task_p2=prod_task(task1,ptr2);

task * task_p3=prod_task(task1,ptr3);

task * task_p4=prod_task(task1,ptr4);

task * task_p5=prod_task(task1,ptr5);

task * task_p6=prod_task(task1,ptr6);

task * task_p7=prod_task(task1,ptr7);

task * task_p8=prod_task(task1,ptr8);

task * task_p9=prod_task(task1,ptr9);

task * task_p10=prod_task(task1,ptr10);

task * task_p11=prod_task(task1,ptr11);

task * task_p12=prod_task(task1,ptr12);

thread_pool(10);//建立线程池,池中最多10个线程

//12个任务

exec_task(task_p1);

exec_task(task_p2);

exec_task(task_p3);

exec_task(task_p4);

exec_task(task_p5);

exec_task(task_p6);

exec_task(task_p7);

exec_task(task_p8);

exec_task(task_p9);

exec_task(task_p10);

exec_task(task_p11);

exec_task(task_p12);

/*延时，让所有任务执行完。也可以不延时，

但是可能任务还没有完成，线程池就被销毁。

*/

sleep(20);

destroy_thread_pool();//销毁线程池

return 0;

}

void task1(void *arg)

{

char *ptr=(char *)arg;

write(STDOUT_FILENO,ptr,strlen(ptr));

}

//提供给用户的外部接口之一，生成任务

task * prod_task(void (*handler)(void *), void * data)

{

struct task * new_task=new task;

if(!new_task)

return NULL;

new_task->handler=handler;

new_task->data=data;

return new_task;

}

//工作队列的相应操作

work_queue_t * init_work_queue()

{

work_queue_t *work_queue_=new work_queue_t ;

if(!work_queue_)

return NULL;

work_queue_->head=work_queue_->tail=NULL;

work_queue_->next=NULL;

work_queue_->elment=NULL;

work_count=0;

return work_queue_;

}

work_queue_t * remove_task()//取队首任务

{

work_queue_t * temp;

if(empty())//工作队列空

return NULL;

temp=work_queue->head;

work_queue->head=work_queue->head->next;

work_count--;

return temp;

}

//在工作队列尾部添加任务

int add_tast(task * new_task)

{

work_queue_t * temp=NULL;

if(empty())//队列为空

{

temp=new work_queue_t ;

temp->next=NULL;

temp->elment=new_task;

work_queue->head=work_queue->tail=temp;

work_count++;

return 0;

}

else//队列不空

{

temp=new work_queue_t ;

temp->next=NULL;

temp->elment=new_task;

work_queue->tail->next=temp;

work_queue->tail=temp;

work_count++;

return 0;

}

return -1;//添加不成功

}

void destory_work_queue()

{

work_queue_t * temp;

if(work_count!=0)

{

while(work_queue->head)

{

temp=work_queue->head;

work_queue->head=work_queue->head->next;

delete temp->elment;

delete temp;

}

}

}

bool empty()

{

bool flage=false;

if(work_count==0)

flage=true;

return flage;

}

//线程池的操作

//初始化线程池

void thread_pool(int init_threads_num)

{

pthread_mutex_init(&queue_lock,NULL);//初始化锁

if(pthread_cond_init(&pool_cond,NULL)!=0)

return ;

work_queue=init_work_queue();//工作队列

if(!work_queue)

return ;

max_thread=init_threads_num;

idles=0;

busy=0;

to_exit=false;

validate=true;

}

//销毁线程池和工作队列,条件变量，锁

void destroy_thread_pool()

{

pthread_mutex_lock(&queue_lock);

//改变条件

to_exit=true;

validate=false;

//取消线程池中的所有线程

for(size_t i=0;i!=threads.size();++i)

pthread_cancel(threads[i]);

//销毁工作队列

destory_work_queue();

pthread_mutex_unlock(&queue_lock);

//销毁锁和条件变量

pthread_mutex_destroy(&queue_lock);

pthread_cond_destroy(&pool_cond);

}

int exec_task(task * new_task)

{

pthread_t tid;

pthread_mutex_lock(&queue_lock);

//将新任务添加至工作队列

if(add_tast(new_task)!=0)

{

pthread_mutex_unlock(&queue_lock);

return -1;

}

pthread_cond_signal(&pool_cond);//工作队列中有任务了，唤醒一个阻塞线程

//是否新建线程，视条件而定

if(validate&&!to_exit&&(idles==0||(idles+busy)

{

if(pthread_create(&tid,NULL,thread_rounter,NULL)!=0)

{

pthread_mutex_unlock(&queue_lock);

return -1;

}

threads.push_back(tid);//记录线程id

idles++;//多了一个空闲线程

pthread_mutex_unlock(&queue_lock);

return 0;

}

pthread_mutex_unlock(&queue_lock);

return 0;

}

void *thread_rounter(void *)

{

pthread_detach(pthread_self());//分离自己

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);

pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);//到达取消点处才取消线程

work_queue_t * work_item=NULL;

for(;;)//去检查工作队列中是否有需要处理的工作项目

{

pthread_mutex_lock(&queue_lock);

while(validate&&!to_exit&&((work_item=remove_task())==NULL))//工作队列为空,则一直等待

pthread_cond_wait(&pool_cond,&queue_lock);//这里将会是一个取消点

pthread_mutex_unlock(&queue_lock);

if(validate&&!to_exit&&work_item->elment->data)

{

pthread_mutex_lock(&queue_lock);

busy++;//该线程忙

idles--;

pthread_mutex_unlock(&queue_lock);

work_item->elment->handler(work_item->elment->data);//处理函数调用

pthread_mutex_lock(&queue_lock);

busy--;

idles++;

pthread_mutex_unlock(&queue_lock);

//释放资源

delete work_item->elment;

delete work_item;

}

}

return NULL;

}

（编辑：温州站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!