目标
1.用于执行大量相对短暂的任务
2.当任务增加的时候能够动态的增加线程池中线程的数量值到达一个阈值
3.当任务执行完毕的时候,能够动态的销毁线程池中的线程
4.该线程池的实现本质上也是生产者与消费者模型的应用。生产者线程向任务队列添加任务,一旦队列有任务到来,如果有等待线程就唤醒来执行任务,如果没有等待线程并且线程数没有达到阈值,就创建线程来执行任务。
线程池拥有若干个线程,通常情况下都小于并发的任务量,所以任务需要进入队列进行等待。
线程中池中线程个数的确定和任务的类型有关系
计算密集型任务,占用CPU较长时间,很少被打断,此时线程池中线程的个数=CPU个数最佳,如果线程个数超过CPU个数,而CPU个数是一定的,这意味着能够并发的数目是一定的,这是就是少量的CPU调度较多的线程,涉及到线程间的切换开销,因为会降低效率
I/O密集型任务,当执行任务的时候,可能会被I/O中断,也就是线程会被挂起,这种情况线程个数>CPU个数是合理的,假设CPU个数为2,分配的线程个数也为2,此时两个线程都可以执行I/O任务,但是有这种情况是两个线程都阻塞在I/O,这时让出了CPU的控制权,此时如果又来了任务,但是线程个数只有2个,而都处于阻塞,也就没有办法执行,因而对于I/O密集型任务,线程个数要大于CPU个数
线程池代码
condition.h
#ifndef _CONDITION_H_
#define _CONDITION_H_
#include <pthread.h>
//封装一个互斥量和条件变量作为状态
typedef struct condition
{
//条件变量总是和互斥锁配合使用
pthread_mutex_t pmutex;
pthread_cond_t pcond;
}condition_t;
//对状态的操作函数
//初始化一个条件变量
int condition_init(condition_t *cond);
//对互斥锁锁定
int condition_lock(condition_t *cond);
//对互斥锁解锁
int condition_unlock(condition_t *cond);
//在条件变量之上等待条件
int condition_wait(condition_t *cond);
//具有超时的等待功能
int condition_timedwait(condition_t *cond, const struct timespec *abstime);
//向等待线程发起通知
int condition_signal(condition_t* cond);
//向等待广播
int condition_broadcast(condition_t *cond);
//销毁条件变量
int condition_destroy(condition_t *cond);
#endif
condition.c
#include "condition.h"
//初始化
int condition_init(condition_t *cond)
{
int status;
if((status = pthread_mutex_init(&cond->pmutex, NULL)))
return status;
if((status = pthread_cond_init(&cond->pcond, NULL)))
return status;
return 0;
}
//加锁
int condition_lock(condition_t *cond)
{
return pthread_mutex_lock(&cond->pmutex);
}
//解锁
int condition_unlock(condition_t *cond)
{
return pthread_mutex_unlock(&cond->pmutex);
}
//等待
int condition_wait(condition_t *cond)
{
return pthread_cond_wait(&cond->pcond, &cond->pmutex);
}
//固定时间等待
int condition_timedwait(condition_t *cond, const struct timespec *abstime)
{
return pthread_cond_timedwait(&cond->pcond, &cond->pmutex, abstime);
}
//唤醒一个睡眠线程
int condition_signal(condition_t* cond)
{
return pthread_cond_signal(&cond->pcond);
}
//唤醒所有睡眠线程
int condition_broadcast(condition_t *cond)
{
return pthread_cond_broadcast(&cond->pcond);
}
//销毁
int condition_destroy(condition_t *cond)
{
int status;
if((status = pthread_mutex_destroy(&cond->pmutex)))
return status;
if((status = pthread_cond_destroy(&cond->pcond)))
return status;
return 0;
}
threadpool.h
#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_
//线程池头文件
#include "condition.h"
//任务结构体,将任务放入队列由线程池中的线程来执行
typedef struct task
{
void *(*run)(void *args); //任务回调函数
void *arg; //参数
struct task *next; //任务队列中下一个任务
}task_t;
//下面是线程池结构体
typedef struct threadpool
{
condition_t ready; //任务准备就绪或者线程池销毁通知
task_t *first; //任务队列中第一个任务
task_t *last; //任务队列中最后一个任务
int counter; //线程池中当前线程数
int idle; //线程池中空闲线程数
int max_threads; //线程池最大允许线程数
int quit; //是否退出标志,1表示退出
}threadpool_t;
//线程池初始化
void threadpool_init(threadpool_t *pool, int threads);
//往线程池中加入任务
void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg);
//摧毁线程池
void threadpool_destroy(threadpool_t *pool);
#endif
threadpool.c
#include "threadpool.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <time.h>
//创建的线程执行
void *thread_routine(void *arg)
{
struct timespec abstime;
int timeout;
printf("thread %d is starting\n", (int)pthread_self());
threadpool_t *pool = (threadpool_t *)arg;
while(1)
{
//是否超时标记
timeout = 0;
//访问线程池之前需要加锁
condition_lock(&pool->ready);
//既然处于等待状态,空闲线程数增加一个
pool->idle++;
//等待队列有任务到来 或者 收到线程池销毁通知,如果不满足,就循环
while(pool->first == NULL && !pool->quit)
{
//否则线程阻塞等待
printf("thread %d is waiting\n", (int)pthread_self());
//获取从当前时间,并加上等待时间, 设置进程的超时睡眠时间
clock_gettime(CLOCK_REALTIME, &abstime);
//表示超时时间是2s
abstime.tv_sec += 2;
int status;
//等待超时函数,如果超时,线程池中没有任务了,线程可以销毁了
status = condition_timedwait(&pool->ready, &abstime); //该函数会解锁,允许其他线程访问,当被唤醒时,加锁
if(status == ETIMEDOUT)
{
printf("thread %d wait timed out\n", (int)pthread_self());
timeout = 1;
break;
}
}
//等待到条件,处于工作状态
pool->idle--;
//等待到了任务
if(pool->first != NULL)
{
//取出等待队列最前的任务,移除任务,并执行任务
task_t *t = pool->first;
pool->first = t->next;
//由于任务执行需要消耗时间,先解锁让其他线程访问线程池
condition_unlock(&pool->ready);
//执行任务
t->run(t->arg);
//执行完任务释放内存
free(t);
//重新加锁
condition_lock(&pool->ready);
}
//等待到线程池销毁通知(通过在threadpool_destroy函数中设置 pool->quit = 1;),且任务执行完毕
if(pool->quit && pool->first == NULL)
{
pool->counter--;//当前工作的线程数-1
//若线程池中没有线程,通知等待线程(主线程)全部任务已经完成
if(pool->counter == 0)
{
condition_signal(&pool->ready);
}
condition_unlock(&pool->ready);
break;
}
//超时,跳出销毁线程
if(timeout == 1)
{
pool->counter--;//当前工作的线程数-1
condition_unlock(&pool->ready);
break;
}
condition_unlock(&pool->ready);
}
printf("thread %d is exiting\n", (int)pthread_self());
return NULL;
}
//线程池初始化
void threadpool_init(threadpool_t *pool, int threads)
{
condition_init(&pool->ready);
pool->first = NULL;
pool->last =NULL;
pool->counter =0;
pool->idle =0;
pool->max_threads = threads;
pool->quit =0;
}
//增加一个任务到线程池
void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg)
{
//产生一个新的任务
task_t *newtask = (task_t *)malloc(sizeof(task_t));
newtask->run = run;
newtask->arg = arg;
newtask->next=NULL;
//新加的任务放在队列尾端
//线程池的状态被多个线程共享,操作前需要加锁
condition_lock(&pool->ready);
if(pool->first == NULL)//第一个任务加入
{
pool->first = newtask;
}
else
{
pool->last->next = newtask;
}
pool->last = newtask; //队列尾指向新加入的线程
//线程池中有线程空闲,唤醒
if(pool->idle > 0)
{
//唤醒至少一个阻塞在条件变量上的线程
condition_signal(&pool->ready);
}
//当前线程池中线程个数没有达到设定的最大值,创建一个新的线性
else if(pool->counter < pool->max_threads)
{
pthread_t tid;
//创建出来的线程执行函数thread_routine,该函数执行结束,线程也就结束
pthread_create(&tid, NULL, thread_routine, pool);
pool->counter++;
}
//结束,访问
condition_unlock(&pool->ready);
}
//线程池销毁
//等待线程将所有任务执行完毕之后在销毁
void threadpool_destroy(threadpool_t *pool)
{
//如果已经调用销毁,直接返回
if(pool->quit)
{
return;
}
//加锁
condition_lock(&pool->ready);
//设置销毁标记为1
pool->quit = 1;
//线程池中当前线程个数大于0
if(pool->counter > 0)
{
if(pool->idle > 0)
{
condition_broadcast(&pool->ready);
}
//处于执行任务状态中的线程,不会收到广播
//线程池中需要等待执行任务状态中的线程全部退出
while(pool->counter)
{
//现在处于等待,那么谁发起通知呢?在第66行
condition_wait(&pool->ready);
}
}
condition_unlock(&pool->ready);
condition_destroy(&pool->ready);
}
main.c
#include "threadpool.h"
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
void* mytask(void *arg)
{
printf("thread %d is working on task %d\n", (int)pthread_self(), *(int*)arg);
sleep(1);
free(arg);
return NULL;
}
//测试代码
int main(void)
{
//创建一个线程池
threadpool_t pool;
//初始化线程池,最多三个线程
threadpool_init(&pool, 4);
int i;
//创建十个任务
for(i=0; i < 20; i++)
{
int *arg = malloc(sizeof(int));
*arg = i;
threadpool_add_task(&pool, mytask, arg);
}
threadpool_destroy(&pool);
return 0;
}
makefile
.PHONY:clean
CC=gcc
CFLAGS=-Wall -g
ALL=main
all:$(ALL)
OBJS=threadpool.o main.o condition.o
.o.c:
$(CC) $(CFLAGS) -c $<
main:$(OBJS)
$(CC) $(CFLAGS) $^ -o $@ -lpthread -lrt
clean:
rm -f $(ALL) *.o