#ifndef __DEF_H__
#define __DEF_H__
#include <stddef.h>
#include <pthread.h>
#include <stdio.h>
#define TRUE 1
#define FALSE 0
//任务结构体
typedef struct{
void (*thread_function_ptr_) (void*);
void *arg_;
}task_t;
//队列结构体
typedef struct node_t{
task_t data_; //队列结点内存放任务
struct node_t *next_;
}node_t, *pnode_t;
typedef struct{
pnode_t head_;
pnode_t tail_;
size_t size_;
}queue_t;
//线程池结构体
typedef struct{
size_t size_; //线程池大小
pthread_t *threads_; //线程id数组
queue_t queue_; //任务队列
int is_started_; // 线程池状态 是否开启 c 没有bool
pthread_mutex_t mutex_; //互斥锁 各线程互斥访问任务队列
pthread_cond_t cond_; //条件队列 同步主线程和各子线程
}pool_t;
// 线程池的接口
void thread_pool_init(pool_t *pool, size_t size); //初始化线程池
void thread_pool_start(pool_t *pool); // 开启线程池
void thread_pool_add_task(pool_t *pool, task_t task); //往线程池中加入新的任务
int thread_pool_get_task(pool_t *pool, task_t *task);//从线程池中取出任务
void thread_pool_stop(pool_t *pool); // 关闭线程池
void thread_pool_deatroy(pool_t *pool); //销毁 线程池
int thread_pool_is_started(pool_t *pool);// 线程池是否开启
size_t thread_pool_get_size_of_queue(pool_t *pool); //返回线程池任务队列的大小
void* thread_pool_thread_func(void *); //每个线程执行的函数
//队列的接口
void queue_init(queue_t *queue); //初始化队列 这里动态创建队列
void queue_push(queue_t *queue, task_t task); // 入队列
void queue_pop(queue_t *queue); //出队列
void queue_destroy(queue_t *queue); //销毁队列
void queue_clear(queue_t *queue); //清空队列
int queue_is_empty(queue_t *queue); //判断队列是否为空
size_t queue_size(queue_t *queue); //返回队列的大小
task_t queue_top(queue_t *queue); // 返回队首元素
#endif
#include "def.h"
#include <stdlib.h>
#include <assert.h>
void queue_init(queue_t *queue){
queue->head_ = NULL;
queue->tail_ = NULL;
queue->size_ = 0;
}
void queue_push(queue_t *queue, task_t task){
pnode_t pCur = (pnode_t )malloc(sizeof(node_t));
pCur->data_ = task;
pCur->next_ = NULL;
if(queue_is_empty(queue)){
queue->head_= queue->tail_ = pCur;
}
else{
queue->tail_->next_ = pCur;
queue->tail_ = pCur;
}
queue->size_++;
}
void queue_pop(queue_t *queue){
assert(!queue_is_empty(queue));
pnode_t pCur = queue->head_;
queue->head_ = queue->head_->next_;
free(pCur);
queue->size_ --;
}
void queue_destroy(queue_t *queue){
queue_clear(queue);
}
void queue_clear(queue_t *queue){
while(!queue_is_empty(queue)){
queue_pop(queue);
}
}
int queue_is_empty(queue_t *queue){
return queue->size_ == 0;
}
size_t queue_size(queue_t *queue){
return queue->size_;
}
task_t queue_top(queue_t *queue){
return queue->head_->data_;
}
#include "def.h"
#include <stdio.h>
#include <stdlib.h>
#define POOL_SIZE 3
void quare(void *arg){
int num = (int)arg;
printf("%d * %d = %d\n", num, num, num * num);
}
int main(int argc, const char *argv[])
{
pool_t pool;
task_t task;
srand(10000);
thread_pool_init(&pool, POOL_SIZE);
thread_pool_start(&pool);
while(1){
task.thread_function_ptr_ = quare;
task.arg_ = (void *)(rand()%100);
thread_pool_add_task(&pool, task);
sleep(1);
}
thread_pool_stop(&pool);
thread_pool_destroy(&pool);
return 0;
}
#include "def.h"
#include <stdio.h>
/*
* 测试队列
*/
void func_ptr(void *arg){
printf("arg = %d\n", (int)arg);
}
int main(int argc, const char *argv[])
{
queue_t queue;
queue_init(&queue);
task_t task, task_2;
task.thread_function_ptr_ = func_ptr;
task.arg_ = (void *)10;
queue_push(&queue, task);
task_2 = queue_top(&queue);
printf("task_2.arg = %d\n",(int)task_2.arg_);
queue_pop(&queue);
printf("queue_is_empty = %d\n", queue_is_empty(&queue));
return 0;
}
#include "def.h"
#include <stdlib.h>
#include <assert.h>
void thread_pool_init(pool_t *pool, size_t size){
pool->size_ = size;
pool->threads_ = (pthread_t *)malloc(pool->size_ * sizeof(pthread_t));
queue_init(&pool->queue_);
pool->is_started_ = FALSE;
pthread_mutex_init(&pool->mutex_, NULL);
pthread_cond_init(&pool->cond_, NULL);
}
void *thread_pool_thread_func(void * arg){
pool_t *pool = (pool_t *)arg;
task_t task;
while(1){
int ret = thread_pool_get_task(pool, &task);
if(ret == TRUE)
task.thread_function_ptr_(task.arg_);
else //此时说明线程池关闭
break;
}
}
void thread_pool_start(pool_t *pool){
if(pool->is_started_ == FALSE){
pool->is_started_ = TRUE;
int i;
for(i = 0; i < pool->size_; i++){
pthread_create(&pool->threads_[i], NULL,thread_pool_thread_func, (void*)pool);
}
}
}
void thread_pool_add_task(pool_t *pool, task_t task){
assert(pool->is_started_);
pthread_mutex_lock(&pool->mutex_);
queue_push(&pool->queue_, task); //将新任务加入任务队列中去
pthread_cond_signal(&pool->cond_);
pthread_mutex_unlock(&pool->mutex_);
}
int thread_pool_get_task(pool_t *pool, task_t *task){ // 根据返回值判断是否成功取出任务
pthread_mutex_lock(&pool->mutex_);
while(queue_is_empty(&pool->queue_) && pool->is_started_ == TRUE){
pthread_cond_wait(&pool->cond_, &pool->mutex_);
}
if(pool->is_started_ == FALSE){//有可能是关闭线程池时 被唤醒的
pthread_mutex_unlock(&pool->mutex_);
return FALSE;
}
*task = queue_top(&pool->queue_);
queue_pop(&pool->queue_);
pthread_mutex_unlock(&pool->mutex_);
return TRUE;
}
void thread_pool_stop(pool_t *pool){
if(pool->is_started_ == FALSE)
return;
pool->is_started_ = FALSE;
pthread_cond_broadcast(&pool->cond_); //唤醒所有睡眠线程 结束回收资源
int i;
for(i = 0; i < pool->size_; i++){
pthread_join(pool->threads_[i], NULL);
}
queue_clear(&pool->queue_); // 清空任务队列
}
void thread_pool_destroy(pool_t *pool){ // 销毁线程池
thread_pool_stop(pool);
pthread_mutex_destroy(&pool->mutex_); // 销毁互斥锁和条件变量
pthread_cond_destroy(&pool->cond_);
free(pool->threads_); //释放动态分配的内存 线程数组和任务队列
queue_destroy(&pool->queue_);
}
int thread_pool_is_started(pool_t *pool){
return pool->is_started_ == TRUE;
}
size_t thread_pool_get_size_of_queue(pool_t *pool){
return pool->queue_.size_;
}
