线程池
意义
在实际应用场景中线程的多次创建销毁会产生不必要的资源消耗。而线程池可以实现线程的多次复用，避免了重复的创建与销毁
思想
线程池由两部分组成，一部分是存放多个线程的线程池，另一部分是存放任务的队列。
线程池中应该有线程与队列最基本的信息
如线程池中能存放线程的最大量与最小量，池中线程的线程号
队列的容量，头节点，尾节点，当前队列中任务数量等等
当有空闲线程时，若任务队列不为空，该线程则会将任务取出执行，若队列为空则阻塞等待
当任务队列为满时，若有空闲线程，则该线程则会将任务取出执行，若无空闲线程则阻塞等待
因此需要空和满两个条件变量
线程池结构体作为全局变量被多个线程共享，为了防止混乱的发生，需要在访问全局变量之前先加锁
为了更好的管理线程池中资源的分配，当空闲线程数量过多任务过少时，需要适当的回收一部分线程。当任务数量过多空闲任务不足时需要创建一些线程。
typedef struct Pthreadpool//线程结构体
{
task *taskQ;
pthread_t *tidwork;//工作线程号
pthread_t tidmanager;//管理者线程号
pthread_cond_t full;//任务队列空
pthread_cond_t empty;//任务队列
pthread_mutex_t mutexpool;//线程池互斥锁
pthread_mutex_t mutexbusy;//忙线程互斥锁
int queueFornt;//头
int queueRear;//尾
int queuesize;//当前任务队列中的任务数
int queueCapacity;//容量
int minNum;//最小线程数
int maxNum;//最大线程数
int busyNum;//忙线程
int liveNum;//存活线程数
int exitNum;//要杀死的线程个数
int flag;//是否销毁线程池
}Pthreadpool;
typedef struct task
{
void(*function)(void *arg);
void *arg;
}task;
线程池的创建
根据结构体中的内容对其一一初始化处理
Pthreadpool * create_pool(int num,int max,int min)
{
Pthreadpool *pool=(Pthreadpool*)malloc(sizeof(Pthreadpool));
if(pool==NULL){
printf("创建线程池失败\n");
return 0;
}
pool->tidwork=(pthread_t*)malloc(sizeof(pthread_t)*max);
if(pool->tidwork==NULL){
free(pool);
printf("线程号数组创建失败\n");
return 0;
}
memset(pool->tidwork,0,sizeof(pthread_t)*max);
pool->queueCapacity=num;
pool->maxNum=max;
pool->minNum=min;
pool->busyNum=0;
pool->liveNum=min;
pool->exitNum=0;
pool->taskQ=malloc(sizeof(task)*num);
if(pool->taskQ==NULL){
free(pool->tidwork);
free(pool);
printf("线程号数组创建失败\n");
return 0;
}
pool->queueCapacity=num;
pool->queueFornt=0;
pool->queueRear=0;
pool->queuesize=0;
pthread_create(&pool->tidmanager,NULL,manarge,pool);
if (pthread_mutex_init(&pool->mutexpool, NULL) != 0 ||
pthread_mutex_init(&pool->mutexbusy, NULL) != 0 ||
pthread_cond_init(&pool->empty, NULL) != 0 ||
pthread_cond_init(&pool->full, NULL) != 0)
{
free(pool->tidwork);
free(pool);
printf("mutex or condition init fail...\n");
}
int i;
pool->flag=0;
for(i=0;i<min;i++){
pthread_create(&pool->tidwork[i],NULL,worker,pool);
pthread_detach(pool->tidwork[i]);//释放线程，待其结束后系统自动回收
}
return pool;
}
添加任务
void task_push(Pthreadpool* pool,void (*function)(void *arg), void *arg)
{
pthread_mutex_lock(&pool->mutexpool);
while(pool->queuesize==pool->queueCapacity&&!pool->flag){
//当任务队列为满，且未被标记为销毁时阻塞等待
pthread_cond_wait(&pool->full,&pool->mutexpool);
}
if(pool->flag==1){
//若被标记为消毁直接解锁退出
pthread_mutex_unlock(&pool->mutexpool);
return;
}
pool->taskQ[pool->queueRear].function=function;//添加任务函数与参数
pool->taskQ[pool->queueRear].arg=arg;
pool->queueRear=(pool->queueRear+1)%pool->queueCapacity;
pool->queuesize++;
pthread_cond_signal(&pool->empty);//此时任务队列中已有任务唤醒工作线程
pthread_mutex_unlock(&pool->mutexpool);
}
执行任务
void *worker (void* arg)
{
Pthreadpool*pool=(Pthreadpool*)arg;
while(1){
pthread_mutex_lock(&pool->mutexpool);
// 当前任务队列是否为空
while (pool->queuesize == 0 && !pool->flag)
{
// 阻塞工作线程
pthread_cond_wait(&pool->empty, &pool->mutexpool);
// 判断是不是要销毁线程
if (pool->exitNum > 0)
{
pool->exitNum--;
if (pool->liveNum > pool->minNum)
{
//pool->exitNum--;不能将该语句写在此处，若管理者线程连续唤醒多次该线程但条件一直未成立，exitNum仍然大于0。在这种情况下当有生产者线程将其唤醒时，就会在此处退出。
pool->liveNum--;
pthread_mutex_unlock(&pool->mutexpool);
threadExit(pool);
}
}
}
// 判断线程池是否被关闭了
if (pool->flag)
{
pthread_mutex_unlock(&pool->mutexpool);
threadExit(pool);
}
task t;
t.function=pool->taskQ[pool->queueFornt].function;
t.arg=pool->taskQ[pool->queueFornt].arg;
pool->queueFornt=(pool->queueFornt+1)%pool->queueCapacity;
pool->queuesize--;
pthread_cond_signal(&pool->full);//通知任务生产函数生产任务
pthread_mutex_unlock(&pool->mutexpool);
printf("thread %ld start working...\n", pthread_self());
pthread_mutex_lock(&pool->mutexbusy);//忙线程+1
pool->busyNum++;
pthread_mutex_unlock(&pool->mutexbusy);
t.function(t.arg);//执行任务
t.arg==NULL;
pthread_mutex_lock(&pool->mutexbusy);//任务完成后忙线程-1
pool->busyNum--;
pthread_mutex_unlock(&pool->mutexbusy);
}
}
管理者函数
void *manarge (void* arg)
{
Pthreadpool *pool=(Pthreadpool *)arg;
while (!pool->flag)
{
sleep(3);//每隔一段时间查询一次线程池中线程的情况
pthread_mutex_lock(&pool->mutexpool);
int queuesize=pool->queuesize;//得到当前队列中任务的数量
int liveNum=pool->liveNum;//得到当前存活线程数量
pthread_mutex_unlock(&pool->mutexpool);
pthread_mutex_lock(&pool->mutexbusy);
int busyNum=pool->busyNum;//得到当前忙线程数量
pthread_mutex_unlock(&pool->mutexbusy);
//当任务多于存活线程数量时创建线程
if(queuesize>liveNum&&liveNum<pool->maxNum){
pthread_mutex_lock(&pool->mutexpool);
int count=0,i;
for(i=0; i < pool->maxNum && count < NUMBER && pool->liveNum < pool->maxNum; ++i){
if(pool->tidwork[i]==0){
pthread_create(&pool->tidwork[i],NULL,worker,pool);
count++;
pool->liveNum++;
}
}
pthread_mutex_unlock(&pool->mutexpool);
}
//当空闲线程过多时唤醒空闲线程使其退出
if(busyNum*2<liveNum&&liveNum>pool->minNum){
pthread_mutex_lock(&pool->mutexpool);
pool->exitNum=NUMBER;
pthread_mutex_unlock(&pool->mutexpool);
for(int i = 0; i < NUMBER; i++){
pthread_cond_signal(&pool->empty);
}
}
}
}
线程退出函数
void *threadExit(Pthreadpool *pool)
{
pthread_t tid=pthread_self();//获取当前线程的线程号
int i;
for(i=0;i<pool->maxNum;i++){
if(pool->tidwork[i] == tid){
//遍历工作线程号数组找到要销毁的线程
pool->tidwork[i]=0;//将其在线程号数组中的值还原为0
printf("threadExit() called, %ld exiting\n", tid);
break;
}
}
pthread_exit(NULL);
}
线程销毁
void destroy_pool(Pthreadpool * pool)
{
int i;
if(pool==NULL){
return ;
}
pool->flag=1;
pthread_join(pool->tidmanager,NULL);
for(i=0;i<pool->liveNum;i++){
pthread_cond_signal(&pool->empty);
}
if(pool->taskQ){
free(pool->taskQ);
}
if(pool->tidwork){
free(pool->tidwork);
}
pthread_mutex_destroy(&pool->mutexpool);
pthread_mutex_destroy(&pool->mutexbusy);
pthread_cond_destroy(&pool->empty);
pthread_cond_destroy(&pool->full);
free(pool);
pool = NULL;
return ;
}