进程线程----------线程池

​线程池

​通俗的讲就是一个线程的池子，可以循环的完成任务的一组线程的集合

​必要性：

​我们平时创建一个线程，完成某一个任务，等待线程的退出。但当需要创建大量的线程时假设 T1 为创建线程时间，T2 为在线程任务执行时间，T3 为线程销毁时间，当 T1+T3 >T2,这时候就不划算了，使用线程池可以降低频繁创建和销毁线程所带来的开销，任务处理时间比较短的时候这个好处非常显著

​线程池的基本结构 

1.​任务队列，存储需要处理的任务，由工作线程来处理这些任务

2.​线程池工作线程，他是任务队列任务的消费者，等待新任务的信号

​线程池的实现：

​1.创建线程池的基本结构

​任务队列链表    typedef struct Task;                                                          线程池结构体  typedef struct ThreadPool 

​2.线程池初始化

​pool_init()  { 

创建一个线程池结构     

 实现任务队列互斥锁和条件变量的初始化 

 创建n个工作线程  }

3.​线程池添加任务

​pool_add_task {  判断是否有空闲的工作线程

 给任务队列添加一个节点   

给工作线程发送信号newtask }

​4.实现工作线程

​workThread{ 

while(1){

等待newtask任务信号   

从任务队列中删除节点   

执行任务}

}

​5.线程池的销毁

​pool_destory{

删除任务队列链表所有节点，

释放空间   

删除所有的互斥锁条件变量 

删除线程池，

释放空间}

线程池代码：

#include  <pthread.h>
#include <stdio.h>
#include <unistd.h>

#define POOL_NUM  10

typedef  struct Task{
    void *(*func)(void *arg)
     void *arg;
     struct Task *next;
}Task;

typedef struct ThreadPool{
   pthread_mutex_t  taskLock;
   pthread_cond_t newTask;
   
   pthread_t tid[POOL_NUM];
   Task *queue_head;
    int busywork;
}ThreadPool;

ThreadPool *pool;
void pool_int(){
   pool = malloc(sizeof(ThreadPool));
   pthread_mutex_init(&pool->taskLock);
   pthread_cond_init(&pool->newTask);
   pool->queue_head = NULL;
   pool->busywork = 0;
  for(int i=0;i<POOL_NUM;i++){
     pthread_create(&pool->tid[i],NULL,workThread,NULL);
}}

void pool_destory(){
   Task *head;
    while(pool->queue_head! = NULL){
     head = pool->queue_head;
     pool->queue_head = pool->queue_head->next;   
}
    pthread_mutex_destory(&pool->taskLock);
    pthread_cond_destory(&pool->newTask);
    free(pool);

}

int main(){
       pool_init();
       sleep(1);
       for(int i =1;i<20;i++) 
       {
            pool_add_task(i);
        }
        sleep(5);
        pool_destory();

}

void *workThread(void *arg)
{  
    while(1)
    {
         pthread_mutex_lock(&pool->taskLock);
      ui pthread_cond_wait(&pool->newTask,&pool->taskLock);
    	Task *ptask = pool->queue_head;
   	 pool->queue_head = pool->queue_head->next;
    	pthread_mutex_unlock(&pool->taskLock);
   	 ptask->func(ptask->arg); 
    	pool->busywork--;

    }
}

void *realwork(void *arg)
{
     printf("finish work%d\n",(int)arg);


}




void pool_add_task(){
     Task *newTask;
     pthread_mutex_lock(&pool->taskLock);
     while(pool->busywork>=POOL_NUM){
         pthread_mutex_unlock(&pool->taskLock);
         usleeep(10000);
         pthread_mutex_lock(&pool->taskLock); 
        }
        pthread_mutex_unlock(&pool->taskLock);
        newTask = malloc(sizeof(Task));
        newTask->func = readlwork;
        newTask->arg = arg;

       pthread_mutex_lock(&pool->taskLock);
       Task *member  = pool->queue_head;
        if(member == NULL)
         {
                 pool->head = newTask;
         }else{
                while(member->next!=NULL){
                member = member->next;}
                member->next  = newTask; 
         }
       pool->busywork++;
       pthread_cond_signal(&pool->newTask);
       pthread_mutex_unlock(&pool->taskLock);

}

线程的调试​

​显示线程：​info thread

切换线程​：​thread xxx