线程池(1)

//线程池

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include <assert.h>
#include <stdlib.h>
//任务链表
typedef struct worker
{
        void(*process)(void *arg);
        void *arg;//回调函数的参数
        struct worker *next;
}CThread_worker;


//线程池结构
typedef struct
{
        pthread_mutex_t queue_lock;
        pthread_cond_t  queue_ready;

        //链表结构   线程池中所有的等到任务
        CThread_worker *queue_head;

        //是否销毁线程池
        int shutdown;
        pthread_t *threadid;
        //最大活动线程数目
        int max_pthread_num;
        //当前等待队列的任务数目
        int cur_queue_size;
}CThread_pool;




int pool_add_worker(void *(*process)(void *arg), void *arg);
void *thread_routine(void *arg);


static CThread_pool *pool = NULL;

//初始化线程池
        void
pool_init(int max_pthread_num)
{
        pool = (CThread_pool *)malloc(sizeof(CThread_pool));
       
        //互斥锁的初始化
        // int pthread_mutex_init(pthread_mutex_t *restrict mutex,  const pthread_mutexattr_t *restrict attr);
        //　pthread_mutex_init() 函数是以动态方式创建互斥锁的，参数attr指定了新建互斥锁的属性。如果参数attr为空，则使用默认的互斥锁属性，
        //默认属性为快速互斥锁 。互斥锁的属性在创建锁的时候指定.
        pthread_mutex_init(&(pool->queue_lock),NULL);

        //初始化一个条件变量
        //extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
        //cond是一个指向结构pthread_cond_t的指针     cond_attr是一个指向结构pthread_condattr_t的指针
        //　　结构pthread_condattr_t是条件变量的属性结构，和互斥锁一样我们可以用它来设置条件变量是进程内可用还是进程间可用，
        //默认值是PTHREAD_ PROCESS_PRIVATE，即此条件变量被同一进程内的各个线程使用；
        //如果选择为PTHREAD_PROCESS_SHARED则为多个进程间各线程公用。注意初始化条件变量只有未被使用时才能重新初始化或被释放。

        pthread_cond_init(&(pool->queue_ready),NULL);


        pool->queue_head = NULL;

        pool->max_pthread_num = max_pthread_num;

        pool->cur_queue_size = 0;

        pool->shutdown = 0;

        pool->threadid = (pthread_t *)malloc(max_pthread_num * sizeof(pthread_t));

        int i = 0;
        //创建线程池
        for( i = 0 ; i < max_pthread_num; i++)
        {
                pthread_create(&(pool->threadid[i]), NULL, thread_routine, NULL);
        }
}

//向线程池加一个任务
        int 
pool_add_worker(void *(*process)(void *arg), void *arg)
{
        CThread_worker *newworker = (CThread_worker *)malloc(sizeof(CThread_worker));

        newworker->process = process;
        newworker->arg     = arg;
        newworker->next    = NULL;
        
        pthread_mutex_lock(&(pool->queue_lock));

        //将任务加入到等待队列中
        CThread_worker *member = pool->queue_head;

        if( member != NULL)
        {
                while(member->next != NULL)
                {
                        member = member->next;
                }
                member->next = newworker;
        }
        else
        {
                pool->queue_head = newworker;
        }

        //assert(pool->queue_ready != NULL);

        pool->cur_queue_size ++;

        pthread_mutex_unlock(&(pool->queue_lock));

        //等待队列有任务，唤醒一个等待线程
        // pthread_cond_signal函数的作用是发送一个信号给另外一个正在处于阻塞等待状态的线程,
        //使其脱离阻塞状态,继续执行.如果没有线程处在阻塞等待状态,pthread_cond_signal也会成功返回。
        //pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；
        pthread_cond_signal(&(pool->queue_ready));

        return 0;
}

//销毁线程池  等待队列中的任务不会再被执行,但是正在运行的线程会一直把任务运行完再退出

        int
pool_destroy()
{
        if( pool->shutdown)
                return -1;
        pool->shutdown = 1;

        //唤醒所有的等待线程，线程池要销毁
        //如线程池，pthread_cond_broadcast唤醒全部线程
        pthread_cond_broadcast(&(pool->queue_ready));

        //阻塞等待线程退出  否则就成僵尸线成

        int i;

        for( i = 0 ; i < pool->max_pthread_num; i++)
        {
                pthread_join(pool->threadid[i],NULL);
        }
        free(pool->threadid);


        //销毁等待的线程
        CThread_worker *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;
}

        void *
thread_routine(void *arg)
{
        printf("strarting  thread 0x%x\n",pthread_self());

        while(1)
        {
                pthread_mutex_lock(&(pool->queue_lock));

                //如果等待队列为0，不销毁线程池  则处于阻塞状态
                while( pool->cur_queue_size == 0 && !pool->shutdown)
                {
                        printf("thread  0x%x is waiting \n",pthread_self());
                        //　int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
                        //待条件有两种方式：无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait()，
                        //其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待
                        //无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。//
                        //mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），
                        //而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。
                        //在条件满足从而离开pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。
                        pthread_cond_wait(&(pool->queue_ready),&(pool->queue_lock));

                }


                //线程池要销毁
                if( pool->shutdown)
                {
                        pthread_mutex_unlock(&(pool->queue_lock));
                        printf("thread 0x%x will exit\n",pthread_self());
                        pthread_exit(NULL);
                }

                printf("thread 0x%x is strarting to  work \n",pthread_self());

                assert(pool->cur_queue_size != 0);
                assert(pool->queue_head != NULL);

                pool->cur_queue_size --;
                CThread_worker *worker = pool->queue_head;

                pool->queue_head = worker->next;
                pthread_mutex_unlock(&(pool->queue_lock));

                //调用回调函数
                (*(worker->process))(worker->arg);
                free(worker);
                worker = NULL;
        }
        pthread_exit(NULL);
}


        void *
myprocess(void *arg)
{
        printf("thread is 0x%x , working on task %d\n",pthread_self(),*(int *)arg);
        sleep(1);
        return NULL;
}


        int 
main(int argc, char *argv[])
{
        pool_init(3);
        int *workingnum = (int *)malloc(sizeof(int) *10);

        int i;
        for( i =0; i < 10; i++)
        {   
                workingnum[i] = i;
                pool_add_worker(myprocess,&workingnum[i]);
        }   

        sleep(5);
        pool_destroy();
        free(workingnum);
        return 0;
}