C 线程池

销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond)；

参数说明:

cond为销毁的条件变量；

等待条件变量成立

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)

激活一个等待该条件变量的线程

int pthread_cond_signal(pthread_cond_t *__cond);

存在多个等待线程时按入队顺序激活其中一个

2、创建数据结构

任务结构体

struct task
{void *(*task)(void *arg);	/* 任务需要执行的函数 */void *arg;					/* 执行函数的参数 */struct task *next;			/* 下一个任务的地址 */
};

线程池结构体

typedef struct thread_pool
{pthread_mutex_t lock;pthread_cond_t  cond;struct task *task_list;	/*链表结构，线程池中所有等待任务*/pthread_t *tids;		/*存放线程id的指针*/unsigned waiting_tasks; /*当前等待的任务数*/unsigned active_threads;/*线程池中线程数目*/bool shutdown;			/*是否销毁线程池*/
}thread_pool;

3、线程池函数

初始化线程池

/** @description: 初始化线程池* @param {thread_pool*} pool:线程池结构体指针 {unsigned int} max_thread_num: 创建几个线程* @return: false 失败 true 成功*/
bool init_pool(thread_pool *pool, unsigned int threads_number)
{pthread_mutex_init(&pool->lock, NULL);	/*初始化线程锁*/pthread_cond_init(&pool->cond, NULL);	/*初始化条件变量*/pool->shutdown = false;					pool->task_list = malloc(sizeof(struct task));pool->tids = malloc(sizeof(pthread_t) * MAX_ACTIVE_THREADS);if(pool->task_list == NULL || pool->tids == NULL){perror("allocate memory error");return false;}pool->task_list->next = NULL;pool->waiting_tasks = 0;pool->active_threads = threads_number;int i;for(i=0; i<pool->active_threads; i++){if(pthread_create(&((pool->tids)[i]), NULL,routine, (void *)pool) != 0){perror("create threads error");return false;}}return true;
}

向线程池添加任务

/** @description: 向线程池添加任务* @param {thread_pool*} pool:线程池结构体指针 {void *(void *arg)} (*task): 线程的回调函数 {void *} arg: 传入的参数* @return: false 失败 true 成功*/
bool add_task(thread_pool *pool,void *(*task)(void *arg), void *arg)
{struct task *new_task = malloc(sizeof(struct task));if(new_task == NULL){perror("allocate memory error");return false;}new_task->task = task;new_task->arg = arg;new_task->next = NULL;pthread_mutex_lock(&pool->lock);if(pool->waiting_tasks >= MAX_WAITING_TASKS){pthread_mutex_unlock(&pool->lock);fprintf(stderr, "too many tasks.n");free(new_task);return false;}struct task *tmp = pool->task_list;while(tmp->next != NULL)tmp = tmp->next;tmp->next = new_task;pool->waiting_tasks++;pthread_mutex_unlock(&pool->lock);pthread_cond_signal(&pool->cond);return true;
}

向线程池添加线程

/** @description: 向线程池添加线程* @param {thread_pool*} pool:线程池结构体指针 {unsigned int} additional_threads: 添加的线程数* @return: 返回成功的线程数*/
int add_thread(thread_pool *pool, unsigned int additional_threads)
{if(additional_threads == 0)return 0;unsigned int total_threads =pool->active_threads + additional_threads;int i, actual_increment = 0;for(i = pool->active_threads;i < total_threads && i < MAX_ACTIVE_THREADS;i++){if(pthread_create(&((pool->tids)[i]),NULL, routine, (void *)pool) != 0){perror("add threads error");if(actual_increment == 0)return -1;break;}actual_increment++; }pool->active_threads += actual_increment;return actual_increment;
}

线程的回调处理函数

/** @description: 回调处理函数* @param  {void *} arg: 传入的参数* @return: 无*/
void handler(void *arg)
{pthread_mutex_unlock((pthread_mutex_t *)arg);
}
/** @description: 线程的回调处理函数* @param  {void *} arg: 传入的参数* @return: 无*/
void *routine(void *arg)
{thread_pool *pool = (thread_pool *)arg;struct task *p;while(1){pthread_cleanup_push(handler, (void *)&pool->lock);pthread_mutex_lock(&pool->lock);while(pool->waiting_tasks == 0 && !pool->shutdown){pthread_cond_wait(&pool->cond, &pool->lock);}if(pool->waiting_tasks == 0 && pool->shutdown == true){pthread_mutex_unlock(&pool->lock);pthread_exit(NULL);}p = pool->task_list->next;pool->task_list->next = p->next;pool->waiting_tasks--;pthread_mutex_unlock(&pool->lock);pthread_cleanup_pop(0);pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);(p->task)(p->arg);pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);free(p);}pthread_exit(NULL);
}

线程池里取消线程

/** @description: 线程池里取消线程* @param {thread_pool*} pool:线程池结构体指针 {nsigned int} removing_threads: 取消的线程数* @return: 失败返回-1*/
int remove_thread(thread_pool *pool, unsigned int removing_threads)
{if(removing_threads == 0)return pool->active_threads;int remain_threads = pool->active_threads - removing_threads;remain_threads = remain_threads>0 ? remain_threads:1;int i;for(i=pool->active_threads-1; i>remain_threads-1; i--){errno = pthread_cancel(pool->tids[i]);if(errno != 0)break;}if(i == pool->active_threads-1)return -1;else{pool->active_threads = i+1;return i+1;}
}

销毁线程池

/** @description: 销毁线程池* @param {thread_pool*} pool:线程池结构体指针* @return: 成功返回true*/
bool destroy_pool(thread_pool *pool)
{pool->shutdown = true;pthread_cond_broadcast(&pool->cond);int i;for(i=0; i<pool->active_threads; i++){errno = pthread_join(pool->tids[i], NULL);if(errno != 0){printf("join tids[%d] error: %sn",i, strerror(errno));}elseprintf("[%u] is joinedn", (unsigned)pool->tids[i]);}free(pool->task_list);free(pool->tids);free(pool);return true;
}

4、完整代码

由于篇幅较长就不贴出来 代码放百度云，需要的在微信公众号回复【线程】即可获取链接下载

使用：Linux下进入文件夹执行make生成可执行文件test执行即可

如果你觉得文章还不错，可以给个"三连"

我是加班猿，我们下期见