C实现一个简朴的线程池

//threadpool.h    
#ifndef     __THREADPOOL_H__    
#define     __THREADPOOL_H__    
#include    <pthread.h>    
typedef void* (*task_fun)(void*);    
//用链表来维护期待任务    
typedef struct threadtask    
{    
    //任务的执行函数    
    task_fun task;    
    //执行函数的参数    
    void* arg;    
    //下一节点    
    struct threadtask* next;    
}THREAD_TASK;    
        
void* thr_fun(void* arg);//每个线程执行的函数    
int init_task(void);//初始化期待任务链表    
int init_pool(void);//初始化线程池    
//向任务链表中添加任务    
int add_task(task_fun task, void* arg);    
int destroy_poll(void);    
#endif

//threadpool.c    
//对付根基不呈现的错误不举办检测    
#include    <stdio.h>    
#include    <stdlib.h>    
#include    <unistd.h>    
#include    <string.h>    
#include    "threadpool.h"    
//线程池中最多答允的线程数    
#define     THREADPOOLSIZE 3    
//当前期待任务的个数    
static unsigned int taskwaittingnum=0;    
//taskwaittingnum的锁    
pthread_mutex_t g_nummutex= PTHREAD_MUTEX_INITIALIZER;    
//期待任务行列的锁    
pthread_mutex_t g_taskmutex=PTHREAD_MUTEX_INITIALIZER;    
THREAD_TASK* g_pTask=NULL;    
pthread_t tid[THREADPOOLSIZE];    
//是否销毁线程池    
static int isShut=0;    
void* thr_fun(void* arg)    
{    
    task_fun task;    
    void* funarg=NULL;    
    THREAD_TASK* ptmp=NULL;    
            
    while(1)    
    {    
        //假如要销毁线程池，跳出while轮回    
        if( 1==isShut )     
        {    
            break;//跳出while轮回    
        }    
        pthread_mutex_lock(&g_nummutex);    
        //假如当前没有任务需要调治，休眠5000微妙    
        if( 0==taskwaittingnum )    
        {    
            pthread_mutex_unlock(&g_nummutex);    
            usleep(5000);    
            continue;    
        }    
        //当前有任务调治    
        else
        {    
            //需要写入链表，所以要锁定链表    
            pthread_mutex_lock(&g_taskmutex);    
            task=g_pTask->next->task;    
            funarg=g_pTask->next->arg;    
            ptmp=g_pTask->next;    
            g_pTask->next=ptmp->next;    
            taskwaittingnum--;    
            pthread_mutex_unlock(&g_taskmutex);    
            pthread_mutex_unlock(&g_nummutex);    
                    
            free(ptmp);    
            ptmp=NULL;    
            (*task)(funarg);    
        }    
    }    
    pthread_exit(NULL);    
}    
//初始化任务链表，首个节点不消来存储任务    
int init_task(void)    
{    
    g_pTask=(THREAD_TASK*)malloc(sizeof(THREAD_TASK));    
    if( NULL==g_pTask )    
    {    
        printf("init_task malloc fails./n");    
        return -1;    
    }    
    memset(g_pTask, 0, sizeof(THREAD_TASK));    
    g_pTask->next=NULL;    
    return 0;    
}    
//初始化线程池    
int init_pool(void)    
{    
    int ret;    
    int i;    
    for( i=0 ; i<THREADPOOLSIZE ; i++ )    
    {    
        ret=pthread_create(tid+i, NULL, thr_fun, NULL);    
        if( ret!=0 )    
        {    
            printf("init_pool pthread_create:/n%s/n", strerror(ret));    
            return -1;    
        }    
    }    
    return 0;       
}    
int add_task(task_fun task, void* arg)    
{    
    THREAD_TASK* ptmp=NULL;    
    pthread_mutex_lock(&g_nummutex);    
    pthread_mutex_lock(&g_taskmutex);    
    ptmp=g_pTask;    
    while( ptmp->next!=NULL )    
    {    
        ptmp=ptmp->next;    
    }    
    ptmp->next=(THREAD_TASK*)malloc(sizeof(THREAD_TASK));    
    if( NULL==ptmp->next )    
    {    
        printf("add_task malloc fails/n");    
        return -1;    
    }    
    ptmp=ptmp->next;    
    ptmp->task=task;    
    ptmp->arg=arg;    
    ptmp->next=NULL;    
    taskwaittingnum++;    
    pthread_mutex_unlock(&g_nummutex);    
    pthread_mutex_unlock(&g_taskmutex);    
    return 0;    
}    
int destroy_pool(void)    
{    
    isShut=1;    
    pthread_mutex_destroy(&g_nummutex);    
    pthread_mutex_destroy(&g_taskmutex);    
    return 0;    
}

//用来测试的main.c    
#include    <stdio.h>    
#include    "threadpool.h"    
void* task1(void* arg)    
{    
    printf("task1正在运行！/n");    
    sleep(10);    
    printf("task1运行竣事!/n");    
    return NULL;    
}    
void* task2(void* arg)    
{    
    printf("task2正在运行！/n");    
    sleep(10);    
    printf("task2运行竣事！/n");    
    return NULL;    
}    
void* task3(void* arg)    
{    
    printf("task3正在运行！/n");    
    printf("task3运行竣事！/n");    
    return NULL;    
}    
void* task4(void* arg)    
{    
    printf("task4正在运行！/n");    
    printf("task4运行竣事！/n");    
    return NULL;    
}    
int main(int argc, char *argv[])    
{    
    init_task();    
    init_pool();    
    add_task(task1, NULL);    
    add_task(task2, NULL);    
    add_task(task3, NULL);    
    add_task(task4, NULL);    
    sleep(30);    
    destroy_pool();    
    return 0;    
}