根据相关资料，自己实现的线程池

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>

typedef struct CThread_worker
{
    void *(*process)(void *arg);
    void *arg;
    struct CThread_worker *next;
}CThread_worker;


typedef struct 
{
    pthread_mutex_t queue_head;
    pthread_cond_t queue_ready;

    struct CThread_worker *queue_worker;
    pthread_t *pthread_id;

    int max_task_num;
    int cur_task_num;
    int shutdown;

}CThread_pool;

static CThread_pool *pool = NULL;

void pool_init(int);
void add_task_to_pool(void *(*)(void *), void *);
void *pthread_fun(void *);
void pool_destroy();
void *my_process(void *);

int main(int argc, char *argv[])
{
    int max_task_num = 0;
    int i = 0;
    max_task_num = 5;

    pool_init(max_task_num);
     
    int *worker_num;
    worker_num = (int *)malloc(10 * sizeof(int));
    for (i=0; i<10; i++)
    {
        worker_num[i] = i;
        add_task_to_pool(my_process, &worker_num[i]);
    }
    
    sleep(12);
    pool_destroy();
    
    free(worker_num);
    worker_num = NULL;

    return 0;
}


void pool_init(int num)
{
    int i = 0;    
    pool = (CThread_pool *)malloc(sizeof(CThread_pool));
    
    pthread_mutex_init(&(pool->queue_head), NULL);
    pthread_cond_init(&(pool->queue_ready), NULL);

    pool->queue_worker = NULL;
    pool->max_task_num = num;
    pool->cur_task_num = 0;
    pool->shutdown = 0;
    pool->pthread_id = (pthread_t *)malloc(num * sizeof(pthread_t));

    for (i=0; i<num; ++i)
    {
        pthread_create(&(pool->pthread_id[i]), NULL, pthread_fun, NULL);
    }
    
}

void *pthread_fun(void *arg)
{
    CThread_worker *worker = NULL;

    printf("pthread %u is starting
", (unsigned int)pthread_self());
    while (1)
    {
        pthread_mutex_lock(&(pool->queue_head));
        while (pool->cur_task_num == 0 && !pool->shutdown)
        {
            printf("pthread %u is waiting task...

", (unsigned int)(pthread_self()));
            pthread_cond_wait(&(pool->queue_ready), &(pool->queue_head));
        }
        if (pool->shutdown)
        {
            /*线程退出之前，必须解锁，以让其他的线程得以访问该共享资源．*/
            pthread_mutex_unlock(&(pool->queue_head));
            printf("pthread %u is exiting
", (unsigned int)pthread_self());
            pthread_exit(NULL);
        }

        pool->cur_task_num--;
        
        worker = pool->queue_worker;
        pool->queue_worker = worker->next;
/*
        while (worker->next != NULL)
        {
            worker = worker->next;
        }    
*/        
        pthread_mutex_unlock(&(pool->queue_head));

        (*(worker->process))(worker->arg);
    }
    pthread_exit(NULL);
}

void add_task_to_pool(void *(*my_process)(void *), void *arg)
{
    CThread_worker *worker = NULL;
    CThread_worker *p = NULL;
    
    worker = (CThread_worker *)malloc(sizeof(CThread_worker));
    worker->process = my_process;
    worker->arg = arg;
    worker->next = NULL;

    pthread_mutex_lock(&(pool->queue_head));

    p = pool->queue_worker;
    if ( p == NULL)
    {
        pool->queue_worker = worker;
    }
    else
    {
        while (p->next != NULL)
        {
            p = p->next;
        }
        p->next = worker;
    }

    pool->cur_task_num++;

    pthread_mutex_unlock(&(pool->queue_head));

    pthread_cond_signal(&(pool->queue_ready));

}


void pool_destroy()
{
    int i = 0;
    CThread_worker *p = NULL;

    pool->shutdown = 1;
    /*唤醒等待该条件的所有线程．否则线程将处于阻塞状态，等待条件满足．*/
    pthread_cond_broadcast(&(pool->queue_ready));    
    /*阻塞等待线程退出，否则成为僵尸线程．*/
    for (i=0; i<pool->max_task_num; ++i)
    {
        pthread_join(pool->pthread_id[i], NULL);
    }
    free (pool->pthread_id);

    while (pool->queue_worker != NULL)
    {
        p = pool->queue_worker;
        pool->queue_worker = p->next;
        free(p);
    }
    /*信号量和条件变量需要销毁．*/    
    pthread_mutex_destroy(&(pool->queue_head));
    pthread_cond_destroy(&(pool->queue_ready));

    free(pool);
    /*为避免pool成为野指针，将其赋值为空．*/
    pool = NULL;    
}

void *my_process(void *task_id)
{
    printf("thread %u is doing task %d
",(unsigned int)pthread_self(), *(int *)task_id);
    sleep(1);
}