当前位置：首页 > news >正文

线程池/内存池/mysql连接池

news 来源：原创 2025/8/24 3:53:31

线程池介绍

①线程池定义：

维持和管理固定数量线程的结构，用于解决资源频繁创建和销毁的问题。

②线程池组成：

固定数量的线程、队列、任务状态管理。

④线程池的作用：

避免频繁创建和销毁线程，管理线程状态，提高系统资源利用率。

1.线程池的组成部分

①线程：

固定数量的线程用于处理任务。

②队列：

用于管理任务，通常使用队列数据结构。

③锁：

用于保护队列的数据安全，防止并发访问冲突。

2.线程池的线程数量确定

①CPU密集型任务：

线程数量与CPU核心数相同。

②IO密集型任务：

线程数量通常为两倍CPU核心数加二。

③经验公式：
通过测试确定最佳线程数量。

3.线程池的应用场景

①.性能优化：

优化耗时计算和IO操作，提高吞吐量。

②.网络IO优化：

使用线程池并发处理网络数据。

③.框架应用：

在开源框架和工作中使用线程池。

4.线程池的工作原理

①.生产消费模型：

生产者线程抛出任务到队列，消费者线程从队列中取出任务执行。

②.任务状态管理：

队列状态决定线程状态，队列为空时线程休眠，有任务时线程活跃。

③.异步任务：

任务在消费者线程中异步执行，不占用生产者线程。

5.线程池的接口设计

①.接口设计：

暴露精简的接口给用户使用，隐藏具体实现细节。

②.任务执行规范：

定义任务执行的函数指针和上下文参数。

③.线程池对象：

用于标识和管理线程池。

6.线程池的数据结构设计

①.队列设计：

使用双开口队列数据结构，支持追加和弹出操作。

②.原子变量：

用于标记线程池的退出状态，保证线程安全。

③.线程计数器：

存储线程的PID，用于管理和关闭线程。

7.具体线程池的代码实现如下

thrd_pool.c

#include <pthread.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdlib.h>
#include "thrd_pool.h"
#include "spinlock.h"/*** shell: gcc thrd_pool.c -c -fPIC* shell: gcc -shared thrd_pool.o -o libthrd_pool.so -I./ -L./ -lpthread* usage: include thrd_pool.h & link libthrd_pool.so*/typedef struct spinlock spinlock_t;//自旋锁typedef struct task_s {void *next;handler_pt func;void *arg;
} task_t;typedef struct task_queue_s {void *head;void **tail; int block;//阻塞标志spinlock_t lock;pthread_mutex_t mutex;pthread_cond_t cond;//条件变量
} task_queue_t;struct thrdpool_s {task_queue_t *task_queue;atomic_int quit;// 退出标志int thrd_count;pthread_t *threads; // 线程数组，存储线程池中的线程
};// 对称
// 资源的创建   回滚式编程
// 业务逻辑     防御式编程
static task_queue_t *
__taskqueue_create() {int ret;task_queue_t *queue = (task_queue_t *)malloc(sizeof(task_queue_t));if (queue) {ret = pthread_mutex_init(&queue->mutex, NULL);if (ret == 0) {ret = pthread_cond_init(&queue->cond, NULL);if (ret == 0) {spinlock_init(&queue->lock);queue->head = NULL;queue->tail = &queue->head;queue->block = 1;return queue;}pthread_mutex_destroy(&queue->mutex);}free(queue);}return NULL;
}static void
__nonblock(task_queue_t *queue) {pthread_mutex_lock(&queue->mutex);queue->block = 0;//。将其设置为 0，表示队列不再处于阻塞状态，线程可以继续执行。pthread_mutex_unlock(&queue->mutex);pthread_cond_broadcast(&queue->cond);
}static inline void 
__add_task(task_queue_t *queue, void *task) {// 不限定任务类型，只要该任务的结构起始内存是一个用于链接下一个节点的指针void **link = (void**)task;*link = NULL;//task->next=nullspinlock_lock(&queue->lock);*queue->tail /* 等价于 queue->tail->next */ = link;queue->tail = link;spinlock_unlock(&queue->lock);pthread_cond_signal(&queue->cond);//这行代码通过 pthread_cond_signal 唤醒一个因条件变量 queue->cond 而阻塞的线程。
}static inline void * 
__pop_task(task_queue_t *queue) {spinlock_lock(&queue->lock);if (queue->head == NULL) {spinlock_unlock(&queue->lock);return NULL;}task_t *task;task = queue->head;void **link = (void**)task;queue->head = *link;//更新队列的头指针 queue->head，使其指向当前任务的 next 指针（即 *link）。if (queue->head == NULL) {queue->tail = &queue->head;}spinlock_unlock(&queue->lock);return task;
}static inline void * 
__get_task(task_queue_t *queue) {task_t *task;// 虚假唤醒while ((task = __pop_task(queue)) == NULL) {pthread_mutex_lock(&queue->mutex);if (queue->block == 0) {pthread_mutex_unlock(&queue->mutex);return NULL;}// 1. 先 unlock(&mtx)// 2. 在 cond 休眠// --- __add_task 时唤醒// 3. 在 cond 唤醒// 4. 加上 lock(&mtx);pthread_cond_wait(&queue->cond, &queue->mutex);pthread_mutex_unlock(&queue->mutex);}return task;
}static void
__taskqueue_destroy(task_queue_t *queue) {task_t *task;while ((task = __pop_task(queue))) {free(task);}spinlock_destroy(&queue->lock);pthread_cond_destroy(&queue->cond);pthread_mutex_destroy(&queue->mutex);free(queue);
}static void *
__thrdpool_worker(void *arg) {thrdpool_t *pool = (thrdpool_t*) arg;task_t *task;void *ctx;while (atomic_load(&pool->quit) == 0) {task = (task_t*)__get_task(pool->task_queue);if (!task) break;handler_pt func = task->func;ctx = task->arg;free(task);func(ctx);}return NULL;
}static void 
__threads_terminate(thrdpool_t * pool) {atomic_store(&pool->quit, 1);__nonblock(pool->task_queue);int i;for (i=0; i<pool->thrd_count; i++) {pthread_join(pool->threads[i], NULL);}
}static int 
__threads_create(thrdpool_t *pool, size_t thrd_count) {pthread_attr_t attr;//线程属性int ret;ret = pthread_attr_init(&attr);//线程属性初始化if (ret == 0) {pool->threads = (pthread_t *)malloc(sizeof(pthread_t) * thrd_count);//在堆上开辟内存if (pool->threads) {//开辟成功int i = 0;for (; i < thrd_count; i++) {if (pthread_create(&pool->threads[i], &attr, __thrdpool_worker, pool) != 0) {//创建线程break;}}pool->thrd_count = i;pthread_attr_destroy(&attr);if (i == thrd_count)return 0;__threads_terminate(pool);free(pool->threads);}ret = -1;}return ret; 
}void
thrdpool_terminate(thrdpool_t * pool) {atomic_store(&pool->quit, 1);__nonblock(pool->task_queue);
}thrdpool_t *
thrdpool_create(int thrd_count) {thrdpool_t *pool;pool = (thrdpool_t*)malloc(sizeof(*pool));if (pool) {task_queue_t *queue = __taskqueue_create();if (queue) {pool->task_queue = queue;atomic_init(&pool->quit, 0);if (__threads_create(pool, thrd_count) == 0)return pool;__taskqueue_destroy(queue);}free(pool);}return NULL;
}int
thrdpool_post(thrdpool_t *pool, handler_pt func, void *arg) {if (atomic_load(&pool->quit) == 1) return -1;task_t *task = (task_t*) malloc(sizeof(task_t));if (!task) return -1;task->func = func;task->arg = arg;__add_task(pool->task_queue, task);return 0;
}void
thrdpool_waitdone(thrdpool_t *pool) {int i;for (i=0; i<pool->thrd_count; i++) {pthread_join(pool->threads[i], NULL);}__taskqueue_destroy(pool->task_queue);free(pool->threads);free(pool);
}

thrd_pool.h

#ifndef _THREAD_POOL_H
#define _THREAD_POOL_Htypedef struct thrdpool_s thrdpool_t;
// 任务执行的规范 ctx 上下文
typedef void (*handler_pt)(void * /* ctx */);#ifdef __cplusplus
extern "C"
{
#endif// 对称处理
thrdpool_t *thrdpool_create(int thrd_count);void thrdpool_terminate(thrdpool_t * pool);int thrdpool_post(thrdpool_t *pool, handler_pt func, void *arg);void thrdpool_waitdone(thrdpool_t *pool);#ifdef __cplusplus
}
#endif#endif

内存池的介绍

内存池是一种内存管理技术，以下是其简单介绍：

1.内存池的定义

内存池是在程序运行开始时，预先分配一块较大的内存空间作为 “池”，当程序需要申请内存时，直接从这个池中分配小块内存给用户，而不是每次都向操作系统申请；当用户释放内存时，也不是直接归还给操作系统，而是将其放回内存池，以便后续再次使用。

2.内存池的作用

提高内存分配效率：避免了频繁地向操作系统申请和释放内存所带来的开销。因为操作系统进行内存分配的操作相对复杂，涉及到查找合适的内存块、维护内存管理数据结构等，而从内存池中分配内存则可以快速定位到可用的内存块，大大提高了分配速度。

减少内存碎片：连续的内存分配和释放容易导致内存碎片的产生，即内存中存在许多不连续的小空闲块，无法满足较大内存分配的需求。内存池通过合理的管理策略，尽量减少这种碎片的产生，提高内存的利用率。

3.内存池的实现原理

内存块划分：内存池通常会将预先分配的大内存空间划分为不同大小的内存块，以满足不同大小的内存分配请求。这些内存块可以通过链表等数据结构进行组织，方便快速查找和分配。

分配策略：当有内存分配请求时，内存池会根据请求的大小，在相应大小的内存块链表中查找可用的内存块。如果找到，则直接返回该内存块给用户；如果没有找到合适的内存块，可能会根据具体的策略进行一些处理，如尝试从其他大小的内存块中进行拆分，或者申请新的内存空间来扩充内存池。

回收策略：当用户释放内存时，内存池会将释放的内存块标记为可用，并将其放回相应的内存块链表中。有些内存池还会采用一些优化策略，如在一定条件下将相邻的空闲内存块合并成更大的内存块，以减少内存碎片。

4.内存池的应用场景

频繁内存分配的场景：如网络服务器中处理大量的连接请求，每次请求可能都需要分配一些内存来存储相关的数据，如果没有内存池，频繁的内存分配和释放会导致性能下降。使用内存池可以提高服务器的响应速度和稳定性。

实时性要求较高的系统：如嵌入式系统中的实时操作系统，对内存分配的时间有严格要求。内存池可以保证在短时间内快速分配内存，满足实时任务的需求。

在kv存储文章的末尾有具体实现了一种简单的内存池

mysql连接池

1.课程介绍和池化技术概述

①.介绍了课程内容和目标，重点讲解了池化技术的概念及其重要性。

②.池化技术主要用于减少资源创建和销毁的次数，从而提高程序的响应性能，尤其是在高并发场景下。

③.线程池和内存池是常见的池化技术，它们通过复用资源来提升性能。

2.数据库连接池的概念和作用

①.数据库连接池是在程序启动时创建足够的数据库连接，并组成一个连接池。

②.连接池会根据程序需要动态申请、使用和释放连接。

③.数据库连接池可以提升数据库访问的性能，尤其是在高并发处理SQL指令时

3.数据库连接的定义和特性

①.数据库连接是指服务器与数据库之间的连接，通常是通过TCP连接实现的。

②.TCP连接需要经过三次握手建立连接，并通过四次挥手断开连接。

③.数据库连接是一种长连接，需要维护连接的生命周期。

4.请求回应模式和数据库访问模式

①.请求回应模式是服务器与数据库之间的交互模式，服务器主动请求数据并等待数据库的响应。

②.数据库不会主动推送数据给服务器，所有数据交互都是通过请求和回应完成的。

③.这种模式适用于所有基于访问模式的数据库操作。

5.高并发处理和MySQL的网络模型

①.高并发处理是指数据库在处理大量并发请求时的性能表现。

②.MySQL采用IO多路复用的方式来处理并发连接，主要通过select函数监听连接。

③.MySQL会为每条连接分配一个线程，并在线程中处理SQL语句。

6.数据库连接池的限制和考虑因素

①.数据库连接池的大小是受限的，受操作系统资源限制和MySQL的处理能力限制。

②.连接池的大小需要根据实际需求和系统资源进行调整。

③.长连接和短连接的选择取决于具体的应用场景和需求。

7.长连接和短连接的区别

①.长连接是指维持一条连接的活跃状态，复用连接执行SQL语句。

②.短连接是执行SQL语句后立即断开连接，不复用连接。

③.长连接适用于高并发场景，短连接适用于低并发场景。

8.TCP连接的收发数据和MySQL协议

①.TCP连接的收发数据需要遵循MySQL协议进行编码和解码。

②.MySQL驱动需要具备编码和解码MySQL协议的能力。

③.MySQL驱动可以通过官方提供或自定义实现。

9.阻塞IO和非阻塞IO的区别

①.阻塞IO是指IO函数在IO未就绪时会阻塞线程，导致线程无法继续执行其他任务。

②.非阻塞IO则不会阻塞线程，允许线程在等待IO时继续处理其他任务。

③.高性能服务器框架通常使用非阻塞IO。

10.同步连接池和异步连接池的区别

①.同步连接池是指使用同步连接方式访问数据库，会阻塞当前线程等待数据库返回结果。

②.异步连接池使用异步连接方式访问数据库，不会阻塞当前线程，通过另起线程或异步事件处理结果。

③.异步连接池的性能通常高于同步连接池。

11.同步连接的原理和应用场景

①.同步连接的原理是阻塞当前线程等待数据库返回结果。

②.同步连接适用于服务器启动时的资源初始化等场景。

③.同步连接的优点是简单直观，缺点是会阻塞线程。

12.异步连接的原理和应用场景

①.异步连接的原理是另起线程等待数据库结果，或通过异步事件处理结果。

②.异步连接适用于服务器运行过程中的业务处理场景。

③.异步连接的优点是释放主线程的处理能力，缺点是复杂度较高。