一、应用场景
传统并发变成的缺陷：
1.创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多
2. 活动的线程需要消耗系统资源，如果启动太多，会导致系统由于过度消耗内存或“切换过度”而导致系统资源不足
- 遇到特别耗时的任务 ，需要把它当成一个任务放在线程池里处理， 比较复杂的流程可拆分成单个简单的任务再放在线程池中
- 用于异步解耦，如日志的罗盘、 数据库的访问
- 线程资源的开销与cpu核心之间的平衡选择
I/O密集型任务：
当应用程序执行大量I/O操作（例如，网络通信或磁盘读写）时，线程池可以通过创建足够数量的线程来处理等待I/O操作的线程，从而最大化CPU的利用率。线程数 = 2* cpu核数 + 2
CPU密集型任务：
对于计算密集型任务，线程数应接近或等于CPU核心数，以避免过多的上下文切换和资源竞争，从而保持CPU的高效运行。线程数 = cpu核数
混合型任务：
在既有CPU密集型又有I/O密集型任务的情况下，线程池可以根据任务的特性动态调整线程数量，以实现资源的最优分配。 线程数 = (io等待时间 + cpu运算时间)* 核心数 / cpu 运算时间
二、工作原理
线程池由一个任务队列和一组处理队列的线程组成。一旦工作进程需要处理某个可能“阻塞”的操作，不用自己操作，工作进程将其作为一个任务放到线程池的队列，接着会被某个空闲线程提取处理。
线程池是一个生产消费模型，由生产者线程发布任务。一般组成：
1.任务队列： 存放所有的任务。每个任务包含任务回调函数 、任务的上下文参数等
2.执行队列：存放所有的线程，管理线程的空闲和工作状态。
线程池中的线程队列不是绝对必须的组件，但它提供了多种便利和优势，使得线程池的管理和任务调度更加高效。
线程队列的特性：
简化管理：线程队列可以帮助简化线程的管理，使得线程池可以轻松跟踪哪些线程是空闲的，哪些是忙碌的。
支持实现负载均衡算法，确保任务在工作线程之间均匀分配，避免某些线程过载而其他线程空闲。
提高效率：通过线程队列，线程池可以快速地为新任务分配可用线程，从而减少任务等待时间和提高整体处理效率。
动态调整：如果线程池实现了动态调整线程数量的功能，线程队列可以作为一个缓冲，帮助平滑地进行线程的添加或移除。
工作窃取：在工作窃取模型中，线程队列是核心组件，允许忙碌的线程从其他线程的队列中窃取任务，以此平衡负载。
避免资源浪费：没有线程队列的情况下，线程池可能需要不断地创建和销毁线程，这会浪费资源并增加系统负担。
实现复杂的调度策略：线程队列使得实现复杂的调度策略（如优先级调度、轮询调度等）变得更加容易。
同步和协调：线程队列可以与同步机制（如条件变量）结合使用，以协调线程间的工作，避免忙等。
错误恢复：如果任务执行失败，线程队列可以帮助线程池恢复执行，例如通过重新调度失败的任务。
资源限制：线程队列有助于限制活跃线程的数量，防止系统资源的过度消耗。
然而，如果你的应用场景非常简单，或者有特殊的性能要求，你可能会设计一个不包含线程队列的线程池。例如，你可能有一个固定数量的线程，它们不断地轮询任务队列来寻找任务，而不是等待任务分配。这种方法可能会减少一些管理开销，但在大多数情况下，线程队列提供的好处会超过其带来的复杂性。
3.管理组件：条件变量和互斥锁，条件变量通常前后加上互斥锁 、减去互斥锁配合操作
三、主要函数
创建线程池后，可使用事件驱动型框架epoll投递任务到线程池，最后销毁线程池。主要函数：
1.创建线程池
thread_pool_t* thread_pool_init()
{
int err;
pthread_t tid;
uint_t n;
pthread_attr_t attr;
thread_pool_t *tp=NULL;
tp = (thread_pool_t * )calloc(1,sizeof(thread_pool_t));
if(tp == NULL){
fprintf(stderr, "thread_pool_init: calloc failed!\n");
}
//初始化线程池的基本参数，如最大线程数、最小线程数、任务队列容量等
thread_pool_init_default(tp, NULL);
//初始化线程属性对象，并根据需要设置属性，如栈大小、调度策略等
thread_pool_queue_init(&tp->queue);
//创建互斥锁
if (thread_mutex_create(&tp->mtx) != T_OK) {
free(tp);
return NULL;
}
//创建条件变量
if (thread_cond_create(&tp->cond) != T_OK) {
(void) thread_mutex_destroy(&tp->mtx);
free(tp);
return NULL;
}
err = pthread_attr_init(&attr);
if (err) {
fprintf(stderr, "pthread_attr_init() failed, reason: %s\n",strerror(errno));
free(tp);
return NULL;
}
//设置将要创建线程的默认状（detached thread），在这种状态下，线程结束后，系统会自动回收其资源，无需调用 pthread_join()
err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (err) {
fprintf(stderr, "pthread_attr_setdetachstate() failed, reason: %s\n",strerror(errno));
free(tp);
return NULL;
}
//创建线程，设置线程回调函数
for (n = 0; n < tp->threads; n++) {
err = pthread_create(&tid, &attr, thread_pool_cycle, tp);
if (err) {
fprintf(stderr, "pthread_create() failed, reason: %s\n",strerror(errno));
free(tp);
return NULL;
}
}
(void) pthread_attr_destroy(&attr);
return tp;
}
2.投递任务线程池
在线程池中，任务队列可能被多个线程访问，包括投递任务的生产者线程和从队列中取出任务的工作线程。锁可以防止这些线程同时修改队列，从而避免冲突
int_t thread_task_post(thread_pool_t *tp, thread_task_t *task)
{
if (thread_mutex_lock(&tp->mtx) != T_OK) {
return T_ERROR;
}
if (tp->waiting >= tp->max_queue) {
(void) thread_mutex_unlock(&tp->mtx);
fprintf(stderr,"thread pool \"%s\" queue overflow: %ld tasks waiting\n",
tp->name, tp->waiting);
return T_ERROR;
}
task->id = thread_pool_task_id++;
task->next = NULL;
//通知线程池有任务投递进来
if (thread_cond_signal(&tp->cond) != T_OK) {
(void) thread_mutex_unlock(&tp->mtx);
return T_ERROR;
}
*tp->queue.last = task;
tp->queue.last = &task->next;
tp->waiting++;
(void) thread_mutex_unlock(&tp->mtx);
if(debug)fprintf(stderr,"task #%lu added to thread pool \"%s\"\n",
task->id, tp->name);
return T_OK;
}
3.线程入口函数
线程创建时已指定。如果任务队列为空 ，线程阻塞 pthead_cond_wait 。任务投递后线程收到条件变量信号，抢占互斥锁，然后到任务队列取出任务执行。这里使用轮询调度方式：按照任务到达的顺序，将任务分配给工作线程。
还有其他任务调度方式：
优先级对应列：为每个任务分配一个优先级，优先级高的任务先执行。可以用堆等数据结构来快速访问最高优先级的任务。
工作窃取（Work Stealing）
策略：每个工作线程维护自己的任务队列。当一个线程完成自己的任务后，它可以从其他线程的队列中“窃取”任务。
最少工作优先（Least Work First Scheduling）
策略：优先分配任务给完成任务数量最少的线程。
static void *thread_pool_cycle(void *data)
{
thread_pool_t *tp =(thread_pool_t * )data;
int err;
thread_task_t *task;
if(debug)fprintf(stderr,"thread in pool \"%s\" started\n", tp->name);
for ( ;; ) {
if (thread_mutex_lock(&tp->mtx) != T_OK) {
return NULL;
}
tp->waiting--;
while (tp->queue.first == NULL) {
if (thread_cond_wait(&tp->cond, &tp->mtx)
!= T_OK)
{
(void) thread_mutex_unlock(&tp->mtx);
return NULL;
}
}
task = tp->queue.first;
tp->queue.first = task->next;
if (tp->queue.first == NULL) {
tp->queue.last = &tp->queue.first;
}
if (thread_mutex_unlock(&tp->mtx) != T_OK) {
return NULL;
}
if(debug) fprintf(stderr,"run task #%lu in thread pool \"%s\"\n",
task->id, tp->name);
task->handler(task->ctx);
if(debug) fprintf(stderr,"complete task #%lu in thread pool \"%s\"\n",task->id, tp->name);
task->next = NULL;
thread_task_free(task);
//notify
}
}
4.销毁线程池
void thread_pool_destroy(thread_pool_t *tp)
{
uint_t n;
thread_task_t task;
volatile uint_t lock;
memset(&task,'\0', sizeof(thread_task_t));
//执行thread_exit(0)线程退出任务
task.handler = thread_pool_exit_handler;
task.ctx = (void *) &lock;
for (n = 0; n < tp->threads; n++) {
lock = 1;
if (thread_task_post(tp, &task) != T_OK) {
return;
}
//循环使用 sched_yield() 让出 CPU 等待 lock 变为非阻塞状态（即线程安全退出）
while (lock) {
sched_yield();
}
}
//销毁同步机制：条件变量互斥锁
(void) thread_cond_destroy(&tp->cond);
(void) thread_mutex_destroy(&tp->mtx);
//释放内存池
free(tp);
}
好处总结：
1.复用线程资源
2.充分利用系统资源
3.异步执行耗时任务
9051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
