线程池技术

在什么情况下使用线程池？ 

    1.单个任务处理的时间比较短 （即创建线程的时间+销毁线程的时间>任务时间）
    2.将需处理的任务的数量大 （并发事件）

    使用线程池的好处: 

    1.减少在创建和销毁线程上所花的时间以及系统资源的开销 
    2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。

所谓线程池：我的理解就是多个线程执行的是同一个函数，即成了线程池

1：初始化线程池void pool_init (int max_thread_num) 

1.1：创建线程池pthread_create (&(pool->threadid[i]), NULL, (void *)thread_routine, NULL); 

1.2：执行线程函数void * thread_routine (void *arg) 

//线程池初始化
void pool_init (int max_thread_num) 
{ 
    int i = 0;
    //为线程池获取动态内存，用于填充线程池
    pool = (Cthread_pool *) malloc (sizeof (Cthread_pool)); 
    //创建互斥锁
    pthread_mutex_init (&(pool->queue_lock), NULL); 
    /*初始化条件变量*/
    pthread_cond_init (&(pool->queue_ready), NULL); 


    pool->queue_head = NULL; //等待的任务链表


    pool->max_thread_num = max_thread_num;  //线程池中的线程数目
    pool->cur_task_size = 0; //当前正在等待的任务数量


    pool->shutdown = 0;   //处于非关闭状态
    //申请内存用于存放线程id
    pool->threadid = (pthread_t *) malloc (max_thread_num * sizeof (pthread_t)); 


    for (i = 0; i < max_thread_num; i++) 
    {  
    //创建线程         线程的id                  要执行的函数
        pthread_create (&(pool->threadid[i]), NULL, (void *)thread_routine, NULL); 
    } 
} 

//指针函数，返回值为一个指针类型，每个线程的执行函数
void * thread_routine (void *arg) 
{ //pthread_self ()获取线程自身id
    printf ("starting thread 0x%x\n", pthread_self ()); 
    while (1) //循环处理任务
    { 
        pthread_mutex_lock (&(pool->queue_lock)); 
      //判断当前是否没有任务等待并且线程池处于开机状态
        while (pool->cur_task_size == 0 && !pool->shutdown) 
        { 
            printf ("thread 0x%x is waiting\n", pthread_self ()); 
            //使线程池进入等待状态
            pthread_cond_wait (&(pool->queue_ready), &(pool->queue_lock)); 
        } 


        /*线程池要销毁了*/ 
        if (pool->shutdown) //判断线程池是否处于工作状态，若不处于，这销毁
        { 
            /*遇到break,continue,return等跳转语句，千万不要忘记先解锁*/ 
            pthread_mutex_unlock (&(pool->queue_lock)); 
            printf ("thread 0x%x will exit\n", pthread_self ()); 
            pthread_exit (NULL); 
        } 
       
        printf ("thread 0x%x is starting to work\n", pthread_self ()); 


         
        /*待处理任务减1，并取出链表中的头元素*/ 
        pool->cur_task_size--; //当前任务数减一
        Cthread_task *task = pool->queue_head; //获取链表的第一个任务
        pool->queue_head = task->next;  //指针指向链表的下一个任务
        pthread_mutex_unlock (&(pool->queue_lock)); 


        /*调用回调函数，执行任务*/ 
        (*(task->process)) (task->arg); 
        free (task);  //执行完一个任务就释放该task
        task = NULL; 
    } 
    /*这一句应该是不可达的*/ 
    pthread_exit (NULL); 
}

//回调函数

void * myprocess (void *arg) 
{ 
    printf ("threadid is 0x%x, working on task %d\n", pthread_self (),*(int *) arg); 
    sleep (1);/*休息一秒，延长任务的执行时间*/ 
    return NULL; 
} 

2：把任务添加到链表，供线程池执行任务

2.1：构建新任务

2.2：将任务添加进队列

2.3：唤醒等待的线程

/*向线程池中加入任务*/ 
int pool_add_task (void *(*process) (void *arg), void *arg) 
{ 
    /*构造一个新任务*/ 
    Cthread_task *task = (Cthread_task *) malloc (sizeof (Cthread_task)); 
    task->process = process; 
    task->arg = arg; 
    task->next = NULL;


    pthread_mutex_lock (&(pool->queue_lock)); 
    /*将任务加入到等待队列中*/ 
    Cthread_task *member = pool->queue_head; //找到任务的头
    if (member != NULL) //当任务的头不为空
    { 
    //利用while找到最后一个任务
        while (member->next != NULL) 
            member = member->next; 
        member->next = task; //把新任务添加到链表最后一个
    } 
    else 
    { 
        pool->queue_head = task; 
    } 


    pool->cur_task_size++; 
    pthread_mutex_unlock (&(pool->queue_lock)); 
    //唤醒线程池里睡眠状态的线程
    pthread_cond_signal (&(pool->queue_ready)); 
    
    return 0; 
} 

3：销毁线程池

/*销毁线程池，等待队列中的任务不会再被执行，但是正在运行的线程会一直 
把任务运行完后再退出*/ 
int pool_destroy () 
{ 
    if (pool->shutdown) 
        return -1;/*防止两次调用*/ 
    pool->shutdown = 1; 


    /*唤醒所有等待线程，线程池要销毁了*/ 
    pthread_cond_broadcast (&(pool->queue_ready)); 


    /*阻塞等待线程退出，否则就成僵尸了*/ 
    int i; 
    for (i = 0; i < pool->max_thread_num; i++) 
        pthread_join (pool->threadid[i], NULL); //等待线程的结束
    free (pool->threadid); 


    /*销毁等待队列*/ 
    Cthread_task *head = NULL; 
    while (pool->queue_head != NULL) 
    { 
        head = pool->queue_head; 
        pool->queue_head = pool->queue_head->next; 
        free (head); 
    } 
    /*条件变量和互斥量也别忘了销毁*/ 
    pthread_mutex_destroy(&(pool->queue_lock)); 
    pthread_cond_destroy(&(pool->queue_ready)); 
     
    free (pool); 
    /*销毁后指针置空是个好习惯*/ 
    pool=NULL; 
    return 0; 
}