线程池是什么：池化技术之一
面向对象思想：封装
一个程序要用到许多线程，线程池是管理线程的一种方式
一般说三线程两池：
任务线程：生成任务对象并把任务对象添加到 任务池
管理线程：从任务池中取出任务对象，交给 线程池 中的某个线程处理
监督线程：监督线程池中的线程，如果空闲线程数量过少就增加一些，过多就减少一些
简易线程池：
任务池对象
线程池对象
创建并初始化线程池
线程函数：包含监督线程的功能
添加任务到线程池中：任务线程的功能
工作函数
销毁函数
简易线程池：
// 任务类(也是任务池类)
struct job
{
void *(*callback_func)(void *arg); // 任务函数
void *arg; // 数据（函数参数）
struct job *pNext;
};
// 线程池类
struct pthreadPool
{
pthread_t *pthreads; // 数组方式存储所有线程id
struct job *phead; // 任务池头节点
struct job *ptail; // 任务池尾节点
int curNum; // 当前线程数
int maxNum; // 最大线程数限制
// 线程同步
pthread_mutex_t mutex; // 互斥量
pthread_cond_t pool_empty; // 当前池空了
pthread_cond_t pool_not_empty; // 当前池不空
pthread_cond_t pool_not_full; // 当前池不满
pthread_cond_t pool_full; // 当前池满
int job_nums; // 当前任务数
int job_closed; // 是否关闭任务池
int pool_closed; // 是否关闭线程池
};
// 任务函数
void *work(void *arg)
{
char *str = (char *)arg;
printf("``````````任务函数:%s开始\n", str);
sleep(5); // 模拟任务
printf("``````````任务函数:%s结束\n", str);
}
// 线程函数
void *pthread_func(void *arg)
{
// 拿到线程池
struct pthreadPool *pool = (struct pthreadPool *)arg;
if (NULL == pool)
{
return NULL;
}
// 获取具体的任务
struct job *pjob = NULL;
while (1)
{
// 核心就是锁的操作
// 加锁
pthread_mutex_lock(&(pool->mutex));
// 这里进行监督线程工作
// 如果队列为空就阻塞，非空就继续执行
while ((0 == pool->job_nums) && (0 == pool->job_closed))
{
printf("队列为空，阻塞\n");
pthread_cond_wait(&(pool->pool_not_empty), &(pool->mutex));
}
// 如果线程池关闭了就结束线程
if (pool->pool_closed)
{
printf("线程池关闭了，结束线程\n");
pthread_mutex_unlock(&(pool->mutex));
pthread_exit(NULL);
}
// 如果队列不为空就执行任务，当前任务数-1
pool->job_nums--;
pjob = pool->phead;
if (0 == pool->job_nums)
{
pool->phead = pool->ptail = NULL;
printf("任务队列为空，销毁线程函数\n");
pthread_cond_signal(&(pool->pool_empty));
}
else
{
pool->phead = pjob->pNext;
}
// 如果任务队列不满，就添加新任务
if (pool->job_nums < pool->maxNum)
{
printf("任务队列不满，添加新任务\n");
pthread_cond_broadcast(&(pool->pool_not_full));
}
// 解锁
pthread_mutex_unlock(&(pool->mutex));
// 执行线程函数
(*(pjob->callback_func))(pjob->arg);
// 释放任务对象
free(pjob);
pjob = NULL;
}
}
// 创建并初始化线程池
struct pthreadPool *pthreadPool_init(int pthread_nums, int max_nums)
{
// 开内存
struct pthreadPool *pool = (struct pthreadPool *)calloc(1, sizeof(struct pthreadPool));
if (NULL == pool)
{
printf("pthreadPool_init:内存分配失败:%m\n");
return NULL;
}
// 成员赋值
pool->curNum = pthread_nums;
pool->maxNum = max_nums;
pool->job_nums = 0; // 当前0任务
pool->job_closed = pool->job_closed = 0; // 非关闭状态
pool->pthreads = (pthread_t *)calloc(pool->curNum, sizeof(pthread_t));
pthread_mutex_init(&(pool->mutex), NULL);
pthread_cond_init(&(pool->pool_empty), NULL);
pthread_cond_init(&(pool->pool_not_empty), NULL);
pthread_cond_init(&(pool->pool_not_full), NULL);
pthread_cond_init(&(pool->pool_full), NULL);
pool->phead = pool->ptail = NULL;
// 创建线程，阻塞在这里
for (int i = 0; i < pool->curNum; i++)
{
pthread_create(&(pool->pthreads[i]), NULL, pthread_func, (void *)pool);
}
// 返回
return pool;
}
// 添加任务到线程池中
int add_job(struct pthreadPool *pool, void *(*callback_func)(void *arg), void *arg)
{
if (NULL == pool || NULL == callback_func || NULL == arg)
{
printf("pthread_pool:参数错误\n");
return -1;
}
pthread_mutex_lock(&(pool->mutex));
// 阻塞
while ((pool->job_nums >= pool->maxNum) && !(pool->job_closed || pool->pool_closed))
{
printf("任务队列已满，阻塞\n");
pthread_cond_wait(&(pool->pool_not_full), &(pool->mutex));
}
// 关闭
if (pool->job_closed || pool->pool_closed)
{
pthread_mutex_unlock(&(pool->mutex));
return -1;
}
// 往任务池中添加任务
struct job *pjob = (struct job *)calloc(1, sizeof(struct job));
if (NULL == pjob)
{
printf("pthread_pool:内存分配失败:%m\n");
pthread_mutex_unlock(&(pool->mutex));
return -1;
}
pjob->callback_func = callback_func;
pjob->arg = arg;
pjob->pNext = NULL;
if (NULL == pool->phead)
{
pool->phead = pool->ptail = pjob;
// 发信号 队列非空
pthread_cond_signal(&(pool->pool_not_full));
}
else
{
pool->ptail->pNext = pjob;
pool->ptail = pjob;
}
pool->job_nums++;
pthread_mutex_unlock(&(pool->mutex));
}
// 销毁线程池
int destory_pthreadPool(struct pthreadPool *pool)
{
if (NULL == pool)
{
return -1;
}
printf("销毁线程池\n");
// 释放id内存
free(pool->pthreads);
// 如果还有任务，也释放掉
struct job *pjob = pool->phead;
while (pjob)
{
pool->phead = pjob->pNext;
free(pjob);
pjob = pool->phead;
}
// 释放本身
free(pool);
return 0;
}
void pthread_pool()
{
// 创建线程池
struct pthreadPool *pool = pthreadPool_init(5, 20);
// 添加任务
add_job(pool, work, "第1个任务");
add_job(pool, work, "第2个任务");
add_job(pool, work, "第3个任务");
add_job(pool, work, "第4个任务");
add_job(pool, work, "第5个任务");
add_job(pool, work, "第6个任务");
add_job(pool, work, "第7个任务");
add_job(pool, work, "第8个任务");
add_job(pool, work, "第9个任务");
add_job(pool, work, "第10个任务");
add_job(pool, work, "第11个任务");
add_job(pool, work, "第12个任务");
add_job(pool, work, "第13个任务");
add_job(pool, work, "第14个任务");
add_job(pool, work, "第15个任务");
add_job(pool, work, "第16个任务");
add_job(pool, work, "第17个任务");
add_job(pool, work, "第18个任务");
add_job(pool, work, "第19个任务");
add_job(pool, work, "第20个任务");
sleep(20);
destory_pthreadPool(pool);
}复杂一点的线程池（封装严密一些的）
// 封装线程函数参数
struct tp_work_arg_s
{
void *arg;
};
// 封装线程的工作函数
struct tp_work_s
{
void *(*process_job)(void *arg);
};
// 为了方便使用起别名
typedef struct tp_work_arg_s tp_work_arg;
typedef struct tp_work_s tp_work;
// 线程类
struct tp_thread_info_s
{
pthread_t id; // 线程id
int status; // 线程状态 0-空闲 1-工作中
int need_exit; // 线程是否需要退出 1-需要退出 0-不需要退出
pthread_mutex_t thread_lock; // 互斥线程锁
pthread_cond_t thread_cond; // 条件变量
tp_work *work;
tp_work_arg *work_arg;
struct tp_thread_info_s *next;
struct tp_thread_info_s *prev;
};
// 线程池类
struct tp_thread_pool_s
{
int max_thread_num; // 最大线程数
int cur_thread_num; // 当前线程数
int min_thread_num; // 最小线程数
int idle_thread_num; // 空闲线程数
pthread_mutex_t pool_lock; // 整个线程池的互斥锁
pthread_t manager_id; // 线程池管理线程id
struct tp_thread_info_s *thread_head; // 线程链表头
};
// 起别名
typedef struct tp_thread_info_s tp_thread_info;
typedef struct tp_thread_pool_s tp_thread_pool;
// 创建线程池中的线程
tp_thread_info *create_thread(int num)
{
if (num <= 0)
return NULL;
// 双链表
tp_thread_info *head;
tp_thread_info *cur;
tp_thread_info *prev;
// 头节点
head = (tp_thread_info *)calloc(1, sizeof(tp_thread_info));
if (NULL == head)
{
printf("create_thread中calloc创建head线程失败:%m\n");
return NULL;
}
num--;
// 头节点之后的节点
cur = head;
prev = NULL;
while (num--)
{
cur->prev = prev;
cur->next = (tp_thread_info *)calloc(1, sizeof(tp_thread_info));
prev = cur;
cur = cur->next;
}
cur->next = NULL;
return head;
}
// 管理线程的函数
void *tp_manager_thread(void *arg)
{
// 空闲线程数过多，就删掉一些
// 空闲线程过少，就创建一些
int cur; // 当前线程数
int idle; // 空闲线程数
int min; // 最小线程数
int exit_num; // 退出线程数
tp_thread_pool *pool = (tp_thread_pool *)arg;
// 统计三次
int idle_arg[3] = {0};
int averIdle = 0;
while (1)
{
cur = pool->cur_thread_num;
idle = pool->idle_thread_num;
min = pool->min_thread_num;
exit_num = 0;
idle_arg[2] = idle;
averIdle = (idle_arg[0] + idle_arg[1] + idle_arg[2]) / 3;
printf("==========服务器当前状态==========");
printf("总线程数:%d\n", cur);
printf("空闲线程数:%d\n", idle);
printf("平均空闲线程数:%d\n", averIdle);
// 空闲线程过多
if (averIdle > (cur / 2))
{
exit_num = cur / 5;
}
// 修正
if (cur - exit_num < min)
{
exit_num = cur - min;
}
printf("退出线程数:%d\n", exit_num);
// 循环销毁(跳过第一个，第一个不好操作)
tp_thread_info *phead;
for (phead = pool->thread_head->next; phead != NULL && exit_num > 1; phead = phead->next)
{
if (0 != phead->status)
{
pthread_mutex_unlock(&(phead->thread_lock));
continue;
}
phead->need_exit = 1; // 标记为退出线程
pthread_mutex_unlock(&(phead->thread_lock));
exit_num--;
pthread_cond_signal(&(phead->thread_cond));
idle_arg[0] = idle_arg[1];
idle_arg[1] = idle_arg[2];
}
sleep(5); // 每五秒检测一次
} // end of while (1)
}
// 工作函数
void *myWork(void *arg)
{
// tp_work_arg *a = (tp_work_arg *)arg;
// int val = *(int *)a->arg;
// printf("```````线程%ld开始执行任务%d\n", pthread_self(), val);
printf("=========start of work==========\n");
sleep(5); // 模拟耗时操作
printf("=========end of work==========\n");
// printf("```````线程%ld执行任务%d完成\n", pthread_self(), val);
}
// 初始化线程 返回0表示失败
int init_thread(tp_thread_pool *pool, tp_thread_info *thread)
{
// 锁
pthread_mutex_init(&(thread->thread_lock), NULL);
pthread_cond_init(&(thread->thread_cond), NULL);
int r = pthread_create(&(thread->id), NULL, myWork, pool);
if (-1 == r)
{
printf("init_thread中创建线程失败:%m\n");
return 0;
}
// 设置线程分离(自动释放)
pthread_detach(thread->id);
thread->status = 0;
return 1;
}
// 初始化线程池
int init_thread_pool(tp_thread_pool *pool)
{
tp_thread_info *phead = pool->thread_head;
// 创建并初始化线程池中的线程对象
while (phead != NULL)
{
if (init_thread(pool, phead))
{
printf("初始化线程成功：%lu\n", phead->id);
}
else
{
printf("初始化线程失败:%m\n");
return 0;
}
phead = phead->next;
}
// 创建管理线程
int ret = pthread_create(&(pool->manager_id), NULL, tp_manager_thread, pool);
if (-1 == ret)
{
printf("创建管理线程失败:%m\n");
return 0;
}
else
{
printf("创建管理线程成功:%lu\n", pool->manager_id);
}
}
// 创建线程池
tp_thread_pool *creatd_thread_pool(int min, int max)
{
tp_thread_pool *pool = (tp_thread_pool *)calloc(1, sizeof(tp_thread_pool));
if (NULL == pool)
{
printf("calloc创建线程池失败:%m\n");
return NULL;
}
pool->max_thread_num = max;
pool->min_thread_num = min;
pool->idle_thread_num = min;
pthread_mutex_init(&(pool->pool_lock), NULL);
if (pool->thread_head)
free(pool->thread_head);
// 开内存
pool->thread_head = create_thread(pool->min_thread_num);
if (NULL == pool->thread_head)
{
printf("create_thread创建线程失败:%m\n");
free(pool);
return NULL;
}
// 初始化线程池
init_thread_pool(pool);
return pool;
}
// 通知管理线程增加一个线程
tp_thread_info *tp_add_pthread(tp_thread_pool *pool)
{
// 加一个线程到线程链表的末尾
if (pool->cur_thread_num >= pool->max_thread_num)
{
printf("线程池中线程数达到最大值，无法再增加线程\n");
return NULL;
}
tp_thread_info *pnew = (tp_thread_info *)calloc(1, sizeof(tp_thread_info));
tp_thread_info *phead = pool->thread_head;
while (phead->next != NULL)
{
phead = phead->next;
}
phead->next = pnew;
pnew->prev = phead;
pnew->next = NULL;
pnew->status = 0;
pnew->need_exit = 0;
pnew->work = NULL;
pnew->work_arg = NULL;
pthread_mutex_init(&(pnew->thread_lock), NULL);
pthread_cond_init(&(pnew->thread_cond), NULL);
pool->cur_thread_num++;
int r = pthread_create(&(pnew->id), NULL, myWork, pool);
if (-1 == r)
{
printf("tp_add_pthread创建线程失败:%m\n");
free(pnew);
return NULL;
}
pthread_detach(pnew->id);
pool->idle_thread_num++;
return pnew;
}
// 向线程池中添加任务
int tp_add_job(tp_thread_pool *pool, tp_work *worker, tp_work_arg *arg)
{
// 去线程池中找空闲线程，把任务分配给空闲线程并执行任务
tp_thread_info *phead;
tp_thread_info *pnew;
while (1)
{
for (phead = pool->thread_head; phead != NULL; phead = phead->next)
{
if (0 == phead->status)
{
printf("找到空闲线程%lu\n", phead->id);
// 设置为非空闲状态
phead->status = 1;
pool->idle_thread_num--;
pthread_mutex_unlock(&(phead->thread_lock));
phead->work = worker;
phead->work_arg = arg;
// 唤醒该线程
pthread_cond_signal(&(phead->thread_cond));
}
} // end of for(phead=pool->thread_head;phead!=NULL;phead=phead->next)
// 到这里说明没有空闲线程，就需要新增线程
// 这里创建新线程并开内存，在监督线程启动
pthread_mutex_lock(&(pool->pool_lock));
pnew = tp_add_pthread(pool);
if (pnew)
{
pnew->work = worker;
pnew->work_arg = arg;
pthread_cond_signal(&(pnew->thread_cond));
pthread_mutex_unlock(&(pool->pool_lock));
return 1;
}
// 没创建成功就解锁，进行新一轮循环
pthread_mutex_unlock(&(pool->pool_lock));
}
return 1;
}
void pthread_pool_plus()
{
int working[10] = {0};
// 1.创建线程池
tp_thread_pool *pool = creatd_thread_pool(3, 20);
// 2.创建任务池
tp_work *worker = (tp_work *)calloc(1, sizeof(tp_work));
worker->process_job = myWork;
for (int i = 0; i < 10; i++)
{
tp_work_arg *arg = (tp_work_arg *)calloc(1, sizeof(tp_work_arg));
working[i] = i + 60;
arg->arg = (void *)&(working[i]);
tp_add_job(pool, worker, arg);
}
sleep(100);
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
