一个简单的线程池

//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;  
}