线程池
线程池的原理
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。
线程池的原理
线程池的组成主要分为3个部分，这三部分配合工作就可以得到一个完整的线程池：
- 任务队列, 存储需要处理的任务, 由工作的线程来处理这些任务
- 通过线程池提供的API函数，将一个待处理的任务添加到任务队列，或者从任务队列中删除
- 已处理的任务会被从任务队列中删除
- 线程池的使用者，也就是调用线程池函数往任务队列中添加任务的线程就是生产者线程
- 工作的线程（任务队列任务的消费者） ，N个
- 线程池中维护了一定数量的工作线程, 他们的作用是是不停的读任务队列, 从里边取出任务并处理
- 工作的线程相当于是任务队列的消费者角色，
- 如果任务队列为空, 工作的线程将会被阻塞 (使用条件变量/信号量阻塞)
- 如果阻塞之后有了新的任务, 由生产者将阻塞解除, 工作线程开始工作
- 管理者线程（不处理任务队列中的任务），1个
- 它的任务是周期性的对任务队列中的任务数量以及处于忙状态的工作线程个数进行检测
- 当任务过多的时候, 可以适当的创建一些新的工作线程
- 当任务过少的时候, 可以适当的销毁一些工作的线程
任务队列
struct Task
// 任务结构体
typedef struct Task
{
void(*function)(void *arg);
void *arg;
}Task;
线程池定义
// 线程池结构体
struct ThreadPool
struct ThreadPool
{
// 任务队列
Task* taskQ;
int queueCapacity; // 容量
int queueSize; // 当前任务个数
int queueFront; // 队头 -> 取数据
int queueRear; // 队尾 -> 放数据
pthread_t managerID; // 管理者线程ID
pthread_t *threadIDs; // 工作的线程ID
int minNum; // 最小线程数量
int maxNum; // 最大线程数量
int busyNum; // 忙的线程的个数
int liveNum; // 存活的线程的个数
int exitNum; // 要销毁的线程个数
pthread_mutex_t mutexPool; // 锁整个的线程池
pthread_mutex_t mutexBusy; // 锁busyNum变量
pthread_cond_t notFull; // 任务队列是不是满了
pthread_cond_t notEmpty; // 任务队列是不是空了
int shutdown; // 是不是要销毁线程池, 销毁为1, 不销毁为0
};
头文件声明
THREADPOOL.h
#ifndef _THREADPOOL_H
#define _THREADPOOL_H
typedef struct ThreadPool ThreadPool;
// 创建线程池并初始化
ThreadPool *threadPoolCreate(int min, int max, int queueSize);
// 销毁线程池
int threadPoolDestroy(ThreadPool* pool);
// 给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg);
// 获取线程池中工作的线程的个数
int threadPoolBusyNum(ThreadPool* pool);
// 获取线程池中活着的线程的个数
int threadPoolAliveNum(ThreadPool* pool);
//////////////////////
// 工作的线程(消费者线程)任务函数
void* worker(void* arg);
// 管理者线程任务函数
void* manager(void* arg);
// 单个线程退出
void threadExit(ThreadPool* pool);
#endif // _THREADPOOL_H
源文件定义
点击查看代码
// 创建线程池
ThreadPool* threadPoolCreate(int min, int max, int queueSize)
{
ThreadPool* pool = (ThreadPool*)malloc(sizeof(struct ThreadPool));
do
{
if (pool == NULL)
{
printf("malloc ThreadPool failed\n");
break;
}
pool->threadIDs = (pthread_t*)malloc(sizeof(pthread_t) * max); // 创建工作线程ID数组
if (pool->threadIDs == NULL)
{
printf("malloc threadIDs failed\n");
break;
}
memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
pool->minNum = min;
pool->maxNum = max;
pool->busyNum = 0; // 刚创建时, 忙线程为0
pool->liveNum = min; // 存活线程数为最小线程数
pool->exitNum = 0; // 要销毁的线程数为0
if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 || pthread_mutex_init(&pool->mutexBusy, NULL) != 0
|| pthread_cond_init(&pool->notFull, NULL) != 0 || pthread_cond_init(&pool->notEmpty, NULL) != 0)
{
printf("mutex or cond init failed\n");
break;
}
// 任务队列
pool->taskQueue = (Task*)malloc(sizeof(Task) * queueSize);
pool->queueCapacity = queueSize;
pool->queueSize = 0;
pool->queueFront = 0;
pool->queueRear = 0;
pool->shutdown = 0; // 不关闭线程池
// 创建线程
pthread_create(&pool->managerID, NULL, manager, pool);
for (int i = 0; i < min; i++)
{
pthread_create(&pool->threadIDs[i], NULL, worker, pool);
}
return pool;
}while (0);
// 释放资源
if (pool && pool->threadIDs)
{
free(pool->threadIDs);
}
if (pool && pool->taskQueue)
{
free(pool->taskQueue);
}
if (pool)
{
free(pool);
}
return NULL;
}
void* worker(void* arg)
{
ThreadPool* pool = (ThreadPool*)arg;
while (1)
{
pthread_mutex_lock(&pool->mutexPool);
// 任务队列为空, 等待
while (pool->queueSize == 0 && !pool->shutdown) // 任务队列为空, 并且线程池不关闭
{
printf("thread 0x%x is waiting\n", (unsigned int)pthread_self());
pthread_cond_wait(&pool->notEmpty, &pool->mutexPool); // 等待任务队列不为空
// 清除指定数目的空闲线程, 退出线程
if (pool->exitNum > 0)
{
pool->exitNum--;
if (pool->liveNum > pool->minNum)
{
pool->liveNum--;
pthread_mutex_unlock(&pool->mutexPool);
printf("thread 0x%x is exiting\n", (unsigned int)pthread_self());
threadExit(pool);;
}
}
}
// 线程池关闭, 退出
if (pool->shutdown)
{
pthread_mutex_unlock(&pool->mutexPool);
printf("thread 0x%x will exit\n", (unsigned int)pthread_self());
threadExit(pool);
}
// 从任务队列中取出任务
Task task = {NULL, NULL};
task.fp = pool->taskQueue[pool->queueFront].fp;
task.arg = pool->taskQueue[pool->queueFront].arg;
pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
pool->queueSize--;
pthread_cond_signal(&pool->notFull); // 通知可以添加新任务
pthread_mutex_unlock(&pool->mutexPool);
// 执行任务
printf("thread 0x%x start working\n", (unsigned int)pthread_self());
pthread_mutex_lock(&pool->mutexBusy);
pool->busyNum++; // 忙线程数+1
pthread_mutex_unlock(&pool->mutexBusy);
task.fp(task.arg); // 执行任务
//*(task.fp)(task.arg); // 执行任务
free(task.arg); // 释放任务参数
task.arg = NULL;
printf("thread 0x%x end working\n", (unsigned int)pthread_self());
pthread_mutex_lock(&pool->mutexBusy);
pool->busyNum--; // 忙线程数-1
pthread_mutex_unlock(&pool->mutexBusy);
}
return NULL;
}
void* manager(void* arg)
{
ThreadPool * pool = (ThreadPool*)arg;
while (!pool->shutdown)
{
// 每隔3s检测一次
sleep(3);
// 获取线程池的任务数和存活线程数
pthread_mutex_lock(&pool->mutexPool);
int queueSize = pool->queueSize;
int liveNum = pool->liveNum;
pthread_mutex_unlock(&pool->mutexPool);
// 获取忙线程数
pthread_mutex_lock(&pool->mutexBusy);
int busyNum = pool->busyNum;
pthread_mutex_unlock(&pool->mutexBusy);
// 添加和销毁线程
// 任务数 > 存活线程数 && 存活线程数 < 最大线程数
if (queueSize > liveNum && liveNum < pool->maxNum)
{
pthread_mutex_lock(&pool->mutexPool);
int counter = 0;
for (int i = 0; i < pool->maxNum && counter < NUMBER && pool->liveNum < pool->maxNum; i++)
{
if (pool->threadIDs[i] == 0)
{
pthread_create(&pool->threadIDs[i], NULL, worker, pool);
counter++;
pool->liveNum++;
}
}
pthread_mutex_unlock(&pool->mutexPool);
}
// 销毁多余的线程
// 忙线程*2 < 存活线程数 && 存活线程数 > 最小线程数
if (busyNum * 2 < liveNum && liveNum > pool->minNum)
{
pthread_mutex_lock(&pool->mutexPool);
pool->exitNum = NUMBER;
pthread_mutex_unlock(&pool->mutexPool);
// 让工作线程自杀
for (int i = 0; i < NUMBER; i++)
{
pthread_cond_signal(&pool->notEmpty);
}
}
}
return NULL;
}
void threadExit(ThreadPool* pool)
{
pthread_t tid = pthread_self();
for (int i = 0; i < pool->maxNum; i++)
{
if (pool->threadIDs[i] == tid)
{
pool->threadIDs[i] = 0;
printf("thread 0x%x exit\n", (unsigned int)tid);
break;
}
}
pthread_exit(NULL);
}
// 添加任务
void threadPoolAdd(ThreadPool* pool, void(*fp)(void*), void* arg)
{
pthread_mutex_lock(&pool->mutexPool);
while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
{
// 队列满, 等待
pthread_cond_wait(&pool->notFull, &pool->mutexPool);
}
if (pool->shutdown)
{
pthread_mutex_unlock(&pool->mutexPool);
return;
}
// 添加任务
pool->taskQueue[pool->queueRear].fp = fp;
pool->taskQueue[pool->queueRear].arg = arg;
pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
pool->queueSize++;
// 任务队列不为空, 唤醒工作线程
pthread_cond_signal(&pool->notEmpty);
pthread_mutex_unlock(&pool->mutexPool);
}
// 获取线程池中存活线程数
int threadPoolLiveNum(ThreadPool* pool)
{
pthread_mutex_lock(&pool->mutexPool);
int liveNum = pool->liveNum;
pthread_mutex_unlock(&pool->mutexPool);
return liveNum;
}
// 获取线程池中工作线程数
int thradPoolBusyNum(ThreadPool* pool)
{
pthread_mutex_lock(&pool->mutexBusy);
int busyNum = pool->busyNum;
pthread_mutex_unlock(&pool->mutexBusy);
return busyNum;
}
// 销毁线程池
int threadPoolDestroy(ThreadPool* pool)
{
if (pool == NULL)
{
return -1;
}
// 关闭线程池
pool->shutdown = 1;
// 阻塞回收管理者线程
pthread_join(pool->managerID, NULL);
// 唤醒阻塞的消费者线程
for ( int i = 0; i < pool->liveNum; i++)
{
pthread_cond_signal(&pool->notEmpty);
}
// 释放资源
if (pool->taskQueue)
{
free(pool->taskQueue);
}
if (pool->threadIDs)
{
free(pool->threadIDs);
}
pthread_mutex_destroy(&pool->mutexPool);
pthread_mutex_destroy(&pool->mutexBusy);
pthread_cond_destroy(&pool->notFull);
pthread_cond_destroy(&pool->notEmpty);
free(pool);
pool = NULL;
return 0;
}
测试
点击查看代码
void taskFunc(void* arg)
{
int num = *(int*)arg;
printf("thread %ld is working, number = %d\n",
pthread_self(), num);
sleep(1);
}
int main()
{
// 创建线程池
ThreadPool* pool = threadPoolCreate(3, 10, 100);
for (int i = 0; i < 100; ++i)
{
int* num = (int*)malloc(sizeof(int));
*num = i + 100;
threadPoolAdd(pool, taskFunc, num);
}
sleep(30);
threadPoolDestroy(pool);
return 0;
}
本文来自博客园，作者：上旬下旬，转载请注明原文链接：https://www.cnblogs.com/buzhiyou/p/18071884
浙公网安备 33010602011771号