#include "threadpool.h"void *mytask(void *arg){ printf("thread 0x%x% is working on task %d\n", (int)pthread_self, *((int*)arg)); sleep(1);//执行一秒钟 free(arg); return NULL;}int main(void){ threadpool_t pool; threadpool_init(&pool, 3); //测试使用线程池 int i; for(i=0; i<10; i++) { //为了处理静态问题所以创建一个指针进行保存，防止原来变量被更改 int *arg = (int *)malloc(sizeof(int)); *arg = i; threadpool_add_task(&pool, mytask, arg); }sleep(15);//使线程池重新处于等待状态 threadpool_destroy(&pool); return 0;}
> 使用线程池 线程池执行大量相对短暂的任务 >计算密集型任务 线程个数 = CPU个数>IO密集型任务 线程个数 > CUP个数>任务增加时能够动态增加线程池中的数量>任务执行完毕能够动态销毁线程池中的线程#ifndef _CONDITION_H_
#define _CONDITION_H_#include<pthread.h>typedef struct condition{ pthread_mutex_t pmutex; //互斥琐 pthread_cond_t pcond;//条件变量}condition_t;int condition_init(condition_t *cond);//对互斥锁和条件变量初始化int condition_lock(condition_t *cond);//对互斥锁进行操作int condition_unlock(condition_t *cond);int condition_wait(condition_t *cond);int condition_timedwait(condition_t *const struct timespec *abstime);int condition_signal(condition_t *cond);//向等待线程发起一个通知int condition_broadcast(condition_t *cond);//向等待线程广播int condition_destroy(condition_t *cond);//销毁条件变量#endif // _CONDITION_H_
#include<stdio.h>#include "condition.h"#include<pthread.h>int condition_init(condition_t *cond){ int status; if((status = pthread_mutex_init(&cond->pmutex, NULL))) return status; if((status = pthread_cond_init(&cond->pcond, NULL))) return status; return 0;}int condition_lock(condition_t *cond){ return pthread_mutex_lock(&cond->pmutex);}int condition_unlock(condition_t *cond){ return pthread_mutex_unlock(&cond->pmutex);}int condition_wait(condition_t *cond){ return pthread_cond_wait(&cond->pcond, &cond->pmutex);}int condition_timedwait(condition_t *cond, const struct timespec *abstime){ return pthread_cond_timedwait(&cond->pcond, &cond->pmutex, abstime);}int condition_signal(condition_t *cond)//向等待线程发起一个通知{ return pthread_cond_signal(&cond->pcond);}int condition_broadcast(condition_t *cond);//向等待线程广播{ return pthread_cond_broadcast(&cond->pcond);}int condition_destroy(condition_t *cond){ int status; if((status = pthread_mutex_destroy(&cond->pmutex))) return status; if((status = pthread_cond_destroy(&cond->pcond))) return status;}
#ifndef _THREAD_POLL_H_#define _THREAD_POLL_H_#include "condition.h"//线程池结构体typedef struct threadpool{ condition_t ready; //任务准备就绪或者线程池销毁通知 task_t *first; //任务队列头指针 task_t *last; //队列尾 int counter; //当前线程池中线程数目 int idle; //线程池中正在等待任务的线程数目 int max_threads; //线程池最大线程数目 int quit; //销毁线程池时置1}threadpool_t;//初始化线程池void threadpool_init(threadpool_t *pool, int threads);//向线程池中添加任务void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg);//销毁线程池void threadpool_destroy(threadpool_t *pool);#endif //_THREAD_POLL_H_
#include<condition.h>#include<stdio.h>#include <stdlib.h>#include <time.h>#include <errno.h>//新线程创建void *thread_routine(void *arg){//绝对时间struct timespec abstime;int timeout;printf("thread 0x%x% is starting\n", (int)pthread_self());threadpool_t *pool = (threadpool_t *)arg;while(1){condition_lock(&pool->ready);while(pool->first == NULL && !pool->quit){printf("thread 0x%x% is waiting\n", (int)pthread_self());//condition_wait(&pool->ready);//需要连接 -lrt 库clock_gettime(CLOCK_REALTIME, &abstime);abstime.tv_sec += 2;int status = condition_timewait(&pool->ready, &abstime);if(status == ETIMEDOUT){printf("thread 0x%x% is wait timd out\n", (int)pthread_self());timeout = 1;break;}}//等待到条件，处于工作状态pool->idle--;if(pool->first != NULL){//从队列头部取出任务处理task_t *t = pool->first;pool->first = t->next;//执行任务需要时间，需要先进行解锁，使得生产者进程向队列中添加任务condition_unlock(&pool->ready);t->run(t->arg);free(t);condition_lock(&pool->ready);}//如果等到线程池销毁通知,并且任务执行完毕if(pool->quit && pool->first == NULL){pool->counter--;if(pool->counter == 0)condition_signal(&pool->ready);//切记解锁condition_unlock(&pool->ready);break;}//超时if(timeout && pool ->first ==NULL){pool->counter--;//切记解锁condition_unlock(&pool->ready);break;}condition_unlock(&pool->ready);} printf("thread 0x%x% is starting\n", (int)pthread_self()); threadpool_t *pool = (threadpool_t *)arg; while(1) { condition_lock(&pool->ready); pool->idle++; //等待队列有任务到来或者线程池销毁通知 while(pool->first == NULL && !pool->quit) { condition_wait(&pool->ready); } //等待到条件，处于工作状态 pool->idle--; if(pool->first != NULL) { task_t *t = pool->first; pool->first = t->next; t->run } condition_unlock(&pool->ready); } printf("thread 0x%x% is exiting\n", (int)pthread_self()); return NULL;}typedef struct task{ void *(run)(void *arg); //任务回调函数 void *arg; //回调函数参数 struct task *next;}task_t;//初始化线程池void threadpool_init(threadpool_t *pool, int threads){ //对线程池各个字段初始化 condition_init(&pool->ready); pool ->first =NULL; pool ->last = NULL; pool -> counter = 0; pool ->idle = 0; pool ->max_threads = threads; pool ->quit = 0;}//向线程池中添加任务void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg){ void *(*run)(void *arg); //任务回调函数 void *arg; //回调函数参数 struct task * next; //生成新任务 task_t *newtask = (task_t *)malloc(sizeof(task_t)); newtask->run = run; newtask->arg = arg; newtask->next = NULL;//首先进行加锁保证线程安全 condition_lock(&pool->ready); //将任务添加到队列 if(pool->first == NULL) pool->first = newtask; else pool->last->next = newtask; pool->last = newtask; //如果有等待线程则唤醒其中一个 if(pool->idle > 0) { condition_signal(&pool->ready); }else if(pool->counter < pool->max_threads) { //没有等待线程并且不超过最大线程数，则创建 pthread_t tid; pthread_create(&tid, NULL, thread_routine, pool); pool->counter++; } condition_unlock(&pool->ready);}//销毁一个线程池void threadpool_destroy(threadpool_t *pool){if(pool->quit){return;}condition_lock(&pool->ready);pool->quit = 1;if(pool->counter > 0){if(pool->idle > 0)condition_broadcast(&pool->ready);//处于执行任务状态中的线程不会收到广播//线程池需要等待执行任务状态中的线程全部退出while(pool->counter > 0){condition_wait(&pool->ready);}}condition_unlock(&pool->ready);condition_destroy(&pool->ready);}
0 0
