linux c语言多线程应用之线程池的实现

水深无声 2022-03-09 16:52 264阅读 0赞

在传统的多线程服务器模型中是这样实现的：一旦有个请求到达，就创建一个新的线程，由该线程执行任务，任务执行完毕之后，线程就退出。这就是"即时创建，即时销毁"的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数非常频繁，那么服务器就将处于一个不停的创建线程和销毁线程的状态。这笔开销是不可忽略的，尤其是线程执行的时间非常非常短的情况。  
　　线程池就是为了解决上述问题的，它的实现原理是这样的：在应用程序启动之后，就马上创建一定数量的线程，放入空闲的队列中。这些线程都是处于阻塞状态，这些线程只占一点内存，不占用CPU。当任务到来后，线程池将选择一个空闲的线程，将任务传入此线程中运行。当所有的线程都处在处理任务的时候，线程池将自动创建一定的数量的新线程，用于处理更多的任务。执行任务完成之后线程并不退出，而是继续在线程池中等待下一次任务。当大部分线程处于阻塞状态时，线程池将自动销毁一部分的线程，回收系统资源。  
　　下面就用c语言实现简单的线程池：  
pool.h

#ifndef POOL_H
    #define POOL_H
    #include <stdio.h>
    #include <unistd.h>
    #include <assert.h>
    #include <stdlib.h>
    #include <pthread.h>
    #include <string.h>
    
    //任务函数
    typedef struct work
    {
    		void* (*function) (void*);
    		void* agvr;
    		struct work* next;
    }work_t;
    
    typedef struct pool
    {
    		int number; //线程个数
    		pthread_t* pth; //线程标识符
    		int quit; //退出标志
    		work_t* head;
    		pthread_mutex_t mutex;
    		pthread_cond_t  cond;
    }pool_t;
    
    extern void pool_init();
    extern void pool_add_worker();
    extern void pool_destroy();
    
    #endif

pool.c

#include "pool.h"
    
    pool_t* pool=NULL;
    
    void pool_destroy()
    {
    		int number;
    		number=pool->number;
    		work_t* tmp;
    		pool->quit=1;
    		pthread_cond_broadcast(&pool->cond);
    
    		for(int i=0;i<number;i++)
    		{
    				pthread_join(pool->pth[i],NULL);
    		}
    
    		while(pool->head)
    		{
    				tmp=pool->head;
    				pool->head=pool->head->next;
    				free(tmp->agvr);
    				free(tmp);
    		}
    
    		free(pool->pth);
    		free(pool);
    
    		return;
    
    }
    
    void pool_add_worker(void*(*fun)(void*),void* agvr,size_t size)
    {
    		work_t* cur=malloc(sizeof(work_t));
    		cur->function=fun;
    		cur->agvr=malloc(size);
    		cur->next=NULL;
    		memcpy(cur->agvr,agvr,size);
    
    
    		pthread_mutex_lock(&pool->mutex);
    		 //头插
    		cur->next=pool->head;
    		pool->head=cur;
    		pthread_mutex_unlock(&pool->mutex);
    		pthread_cond_signal(&pool->cond);
    
    }
    
    void* routine(void* agvr)  //线程实现函数
    {
    
    		work_t* temp=NULL;
    		while(1)
    		{
    				pthread_mutex_lock(&pool->mutex);
    				while(pool->head == NULL && pool->quit==0) // /* 无任务则阻塞，有任务则跳出 */
    				{
                         printf ("线程[%lx]等待\n",pthread_self()); //pthread_self()获取线程ID
    					 pthread_cond_wait(&pool->cond,&pool->mutex);
    				}
    
    				if(pool->quit==1) //线程退出标志
    				{
    						pthread_mutex_unlock(&pool->mutex);
    						pthread_exit(NULL);
    				}
    
    				assert(pool !=NULL);
                   //创建线程池
    				temp=pool->head;
    				pool->head=pool->head->next;
    				pthread_mutex_unlock(&pool->mutex);
    
    				(temp->function)(temp->agvr);
    				free(temp->agvr);
    				free(temp);
    
    
    
    		}
    }
    
    void pool_init(int number)
    {
    		if(pool !=NULL)
    		{
    			printf("error\n");
    			return;
    		}
    
    		if(number <=0)
    		{
    				printf ("error2\n");
    				return;
    		}
    
    		pool=malloc(sizeof(pool_t));
    		assert(pool !=NULL);
    		memset(pool,0,sizeof(pool_t));
    
    		pool->number=number;
    		pool->pth=malloc(sizeof(pthread_t)*number);
    		pool->quit=0;
    
    		pthread_mutex_init(&pool->mutex,NULL);
    		pthread_cond_init(&pool->cond,NULL);
    
    		for(int i=0;i<number;i++)
    		{
    				if(pthread_create(pool->pth+i,NULL,routine,NULL) !=0)
    				{
    						free(pool->pth);
    						free(pool);
    						printf ("创建线程出错\n");
    						return;
    				}
    		}
    		return;
    }

测试代码：  
Mymain.c

#include <stdio.h>
    #include "pool.h"
    
    void* fun(void* agvr)
    {
    		int id=*(int*)agvr;
    
    		for(int i;i<5;i++)
    		{
    				printf ("线程[%d]正在执行\n",id);
    				sleep(1);
    		}
    		return NULL;
    }
    
    int main()
    {
    
    		int ret;
    		pool_init(8);
    		
    		sleep(2);
    		for(int i=0;i<5;i++)
    		{
    				pool_add_worker(fun,&i,sizeof(i));
    		}
    
    		sleep(5);
    
    		pool_destroy();
    
    		return 0;
    }