linux下C语言实现简单线程池

需要注意的时每次读取和写入任务时注意对数据的保护

下面贴出代码

#include<stdio.h>
#include <errno.h>
#include<pthread.h>
#include<stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
void my_error(const char *error_string, int line);
void add_func(void *(*func)(void *arg),void *arg);
void *mainfun(void *arg);
void init_threadpool(int max);
void destroypool();
void *simplework(void *arg);


void my_error(const char *error_string, int line) //错误处理函数
{
    fprintf(stderr, "line:%d",line);
    perror(error_string);
    exit(1);
}
struct work_list{  //定义任务队列，链表实现
    void *(*func)(void *arg);//处理函数
    void *arg;//处理函数的参数
    struct work_list *next;//指向下一个任务的指针
};
struct pthread_pool{//定义线程池
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int max_threads;
    int work_num;//剩余任务数
    int isdestroy;//是否销毁线程池
    pthread_t* thread;
    struct work_list *list_head;//指向任务队列的头结点
};
struct pthread_pool* pool;
void add_func(void *(*func)(void *arg),void *arg)   //向任务队列中添加任务
{
    struct work_list *a;
    a=(struct work_list *)malloc(sizeof(struct work_list));
    a->next=NULL;
    a->func=func;
    a->arg=arg; //使用尾插法将任务插入任务队列
    if (pool->list_head==NULL)
    {
        pool->list_head=a;
    }
    else {
        struct work_list *p;
        p=pool->list_head;
        while(p->next!=NULL)
        {
            p=p->next;
        }
        p->next=a;
    }
    pool->work_num++;
    pthread_mutex_unlock(&(pool->mutex));
    pthread_cond_signal(&(pool->cond)); //唤醒等待的线程
}
void *mainfun(void *arg) //线程
{
    while(1)
    {
        pthread_mutex_lock(&(pool->mutex));
        while(pool->list_head==NULL&&pool->work_num==0) //若无任务则进入循环，有任务就会先执行任务
        {
            if (pool->isdestroy==1)//若需要销毁线程池
            {
                pthread_mutex_unlock(&(pool->mutex));//注意退出时当前线程一定要先解锁，不然其他线程会阻塞无法退出
                printf("pthread %d has destroyed\n",pthread_self());
                pthread_exit(NULL);
            }
            else {
                printf("%d is waiting\n",pthread_self());
                pthread_cond_wait(&(pool->cond),&(pool->mutex));
                printf("%d is awake\n",pthread_self());
            }
            
        }

        struct work_list *work=pool->list_head;
        pool->list_head=pool->list_head->next;
        pool->work_num--;
        pthread_mutex_unlock(&(pool->mutex));
        (*(work->func)) (work->arg);
        free(work);
        work=NULL;
    }
    pthread_exit(NULL);
}
void init_threadpool(int max)//初始化线程池
{
    pool=(struct pthread_pool *)malloc(sizeof(struct pthread_pool));
    if (pool == NULL)
    {
        my_error("malloc",__LINE__);
    }
    pool->max_threads=max;
    pool->work_num=0;
    pool->isdestroy=0;
    pool->list_head=NULL;
    pthread_mutex_init(&(pool->mutex),NULL);
    pthread_cond_init(&(pool->cond),NULL);
    int i=0;
    pool->thread=(pthread_t*)malloc(max*sizeof(pthread_t));
    if (pool->thread == NULL)
    {
        my_error("malloc",__LINE__);
    }
    int ret;
    for (i=0;i<max;i++)
    {
        ret=pthread_create(&(pool->thread[i]),NULL,mainfun,NULL);
        if (ret!=0)
        {
            my_error("pthread_create",__LINE__);
        }
    }
    printf("init is sucess\n");
}
void destroypool()
{
    pthread_mutex_lock(&(pool->mutex));
    pool->isdestroy=1;
    pthread_mutex_unlock(&(pool->mutex));
  pthread_cond_broadcast(&(pool->cond));
    printf("i call everyone\n");
    int i=0;
    for (i=0;i<pool->max_threads;i++)
    {
        pthread_join(pool->thread[i],NULL);
    }
    free(pool->thread);
    pthread_cond_destroy(&(pool->cond));
    pthread_mutex_destroy(&(pool->mutex));
    free(pool);
}
void *simplework(void *arg)
{
    printf("%d is working %d\n",pthread_self(),*(int*)arg);
    sleep(1);
}
int main()
{
    init_threadpool(10);
    int i=0;
    for (i=0;i<5;i++)
    {
        pthread_mutex_lock(&(pool->mutex));
        add_func(simplework,&i);
    }
    sleep(5);
    destroypool();
    printf("destory compelete\n");
    return 0;
}