线程池

多线程存在的问题
进程所支持线程数量问题（受限）：线程的创建和销毁的开销问题

1任务队列为空时，线程池里的线程阻塞等待
任务队列不为空时，线程池里的线程处理任务
任务队列为满时，不能添加新的任务

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

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


struct job
{
    void  *(*func)(void *arg);
    void  *arg;
    struct job *next;
};


struct threadpool 
{
    int  thread_num;//已开启的线程数量
    pthread_t   *pthread_ids;//保存线程池中的线程id

    struct  job *head ;//任务队列的头
    struct  job *tail;//任务队列的尾
    int queue_max_num;//任务队列的最大数
    int queue_cur_num;//任务队列已有多少个任务

    pthread_mutex_t  mutex;       
    pthread_cond_t queue_empty;//任务队列位空的条件
    pthread_cond_t queue_not_empty;//任务队列位不为空的条件
    pthread_cond_t queue_not_full;//任务队列不为满
};


void *threadpool_function(void *arg )
{
    struct threadpool *pool = (struct threadpool *)arg;
    struct job *pjob = NULL;

     sleep(2);
    while(1)
    {
        pthread_mutex_lock(&(pool->mutex));
        while(pool->queue_cur_num==0)
        {
            pthread_cond_wait(&(pool->queue_not_empty),&(pool->mutex));
        }
        pjob=pool->head;
        pool->queue_cur_num--;

        if(pool->queue_cur_num!=pool->queue_max_num)
        {
               pthread_cond_broadcast(&(pool->queue_not_empty));
        }
        if(pool->queue_cur_num==0)
        {
            pool->head=pool->tail = NULL; 
            pthread_cond_broadcast(&(pool->queue_not_empty));
        }
        else
        {
            pool->head=pool->head->next;
        }
        
        pthread_mutex_unlock(&(pool->mutex));

        pjob->func(pjob->arg);
        free(pjob);
        pjob=NULL;
    }
}


struct threadpool *threadpool_init(int thread_num,int queue_max_num)
{
    struct threadpool *pool = (struct threadpool *)malloc(sizeof(struct threadpool));
    
    //malloc

    pool ->queue_max_num = queue_max_num;
    pool ->queue_cur_num = 0;
    pool ->head=NULL;
    pool -> tail   = NULL;

    pthread_mutex_init(&(pool->mutex),NULL);
    pthread_cond_init(&(pool->queue_empty),NULL);
    pthread_cond_init(&(pool->queue_not_empty),NULL);
    pthread_cond_init(&(pool->queue_not_full),NULL);

    pool ->thread_num=thread_num;
    pool ->pthread_ids = (pthread_t  *)malloc(sizeof(pthread_t) * thread_num);
    
    //malloc

    for (int  i = 0; i < pool->thread_num ; i++)
    {
        pthread_create(& (pool->pthread_ids[i]),NULL,threadpool_function,(void *)pool );
    }
     return pool;
}



void threadpool_add_job(struct threadpool *pool,void *(func)(void *),void  *arg)
{
    pthread_mutex_lock(&(pool->mutex));
      while(pool->queue_cur_num==pool->queue_max_num)
      {
          pthread_cond_wait((&pool->queue_not_full),&(pool->mutex));
      }

     struct job *pjob = (struct job* )malloc(sizeof(struct job));
    //malloc 

    pjob->func = func;
    pjob->arg = arg;
    pjob->next=NULL;
    //pjob->func(pjob->arg);

   if(NULL==pool->head)
   {
       pool->head=pool->tail=pjob;
       pthread_cond_broadcast(&(pool->queue_not_empty));
   }
   else
   {
       pool->tail->next=pjob;
       pool->tail=pjob;
   }
   

   pool->tail->next=pjob;
   pool->tail=pjob;

   pool->queue_cur_num++;

  // printf("%d\n",pool->queue_cur_num);

   pthread_mutex_unlock(&(pool->mutex));
}




void thread_destroy(struct threadpool *pool)
{
    pthread_mutex_lock(&(pool->mutex));\

    while(pool->queue_cur_num!=0)
    {
        pthread_cond_wait(&(pool->queue_empty),&pool->mutex);
    }
    pthread_mutex_unlock(&(pool->mutex));
    pthread_cond_broadcast(&(pool->queue_empty));    
    pthread_cond_broadcast(&(pool->queue_not_empty));
    pthread_cond_broadcast(&(pool->queue_not_full));

    free(pool->pthread_ids);

    for(int i=0;i<pool->thread_num;i++)
    {
        pthread_cancel(pool->pthread_ids[i]);
        pthread_join(pool->pthread_ids[i],NULL);
    }
    
    struct job *temp;
    while(pool->head!=NULL)
    {
        temp=pool->head;
        pool->head=temp->next;
        free(temp);
    }
     free(pool);
}




void *work(void *arg )
{
    char *p = (char *)arg;
    printf("helloc world    %s\n",p);

    printf("welcome to china   %s\n",p );
    sleep(1);
}




int main()
{
    struct threadpool *pool= threadpool_init(10,100);

    threadpool_add_job(pool ,work,"1" );
    threadpool_add_job(pool ,work,"2" );  
    threadpool_add_job(pool ,work,"3" );
    threadpool_add_job(pool ,work,"4" );
    threadpool_add_job(pool ,work,"5" );
    threadpool_add_job(pool ,work,"6" );
    threadpool_add_job(pool, work,"7" );
   threadpool_add_job(pool, work,"8" );
   threadpool_add_job(pool, work,"9" );
   threadpool_add_job(pool, work,"10" );
   
   sleep(20);

   thread_destroy(pool);
    return 0;
}