三大池式组件实现
文章目录
- 线程池：
-
- 项目背景：
- 线程池的实现原理：
-
- 线程池的结构：
- 线程数组：
- 任务队列：
- 任务队列和线程数组的不同：
- 管理者线程：
- 整体代码：
-
- thread_pool.h
- thread_pool.c
- MySQL的连接池
-
- 关键技术点：
- 项目源码：
- 项目背景：
- 连接池功能点介绍：
- 功能实现设计：
-
- 代码结构：
- 实现要点：
- 准备工作：
-
- 创建数据库和表：
- 创建配置文件mysql.ini：
- 执行日志log.h：
- 封装与`MySQL Server`交互操作：
-
- Connection.h
- Connection.cpp：
- 测试与mysql的连接并发送插入语句：
- windows下visual studio遇到的问题：
- 连接池的实现：
-
- ConnectionPool.h：
- ConnectionPool.cpp：
- 连接池压力测试：
-
- 单线程测试：
-
- 未使用线程池：
- 使用线程池：
- 多线程测试：
-
- 未使用线程池：
- 使用线程池：
- 测试结果：
-
- 通过插入操作，衡量使用连接池对性能的影响：
- 结论：
- 内存池的实现：
-
- 为何需要内存池？
- 分析SGI STL二级空间配置器内存池实现原理：
-
- 空间配置器的相关定义：
- 二级空间配置器源码分析：
-
- 重要的类型和变量定义：
- 重要的辅助接口函数：
- 内存池管理函数：
- SGI STL二级空间配置器内存池的优点：
- 自实现stl_alloc功能：
-
-
- __malloc_alloc_template.h
- MyAllocator.h
- main.cpp
-
- nginx的内存池实现原理：
-
- nginx内存池源码分析：
-
- 内存池的关系图：
- 重要类型定义：
- 重要函数接口：
- ngx_create_pool创建内存池：
- ngx_palloc内存分配函数（支持内存对齐）：
-
- ngx_palloc_small小块内存分配
- ngx_palloc_large大块内存分配：
- ngx_pfree内存释放：
- ngx_reset_pool内存池重置：
- ngx_destroy_pool销毁内存池：
- 测试用例：
-
- 环境配置：
- test_ngx_memoryPool.c
- 编译连接命令：
- 自实现nginx_palloc的功能：
-
- ngx_memoryPool.h
- ngx_memoryPool.cpp
- main.cpp
线程池：
项目背景：
线程池是一种多线程处理形式，大多用于高并发服务器上，为了有效的利用高并发服务器上的线程资源。
网络编程中，线程与进程处理各项分支子功能，通常是：接收消息 ==> 消息分类 ==> 线程创建 ==> 传递消息到子线程 ==> 线程分离 ==> 在子线程中执行任务 ==> 任务结束退出。
当出现大量消息频繁请求服务器时，频繁的创建与销毁线程会带来极大的开销，这会造成内存资源的极度浪费。
线程池，则允许一个线程多次复用，且每次复用的线程内部的消息处理可以不相同，从而能节省创建与销毁的开销。
线程池的实现原理：
线程池的结构：
- 线程池状态信息：描述当前线程池的基本信息，如是否开启
shutdown、最小线程数min_thr_num、最大线程数max_thr_num、存活线程数live_thr_num、忙线程数busy_thr_num、待销毁线程数wait_exit_thr_num等； - 线程数组、管理者线程：各自的线程
ID分别存放在threads和adjust_tid中； - （环形）任务队列信息：描述当前任务队列基本信息，如任务队列的首地址、最大任务数、实际任务数、队列头/尾的下标、队列不为满条件变量、队列不为空条件变量等；
- 多线程互斥锁：整个线程池的互斥锁
lock、忙线程数变量锁thread_counter。保证同一时间点上，只有一个线程在任务队列中取任务并修改任务队列、线程池的信息； - 函数指针：在打包消息阶段，将分类后的消息处理函数放在(*function)；
- void*类型参数：用于传递消息处理函数需要的信息。
/* 描述线程池相关信息 */
struct threadpool_t {
pthread_mutex_t lock; /* 锁住整个结构体 */
pthread_mutex_t thread_counter; /* 记录忙线程数busy_thr_num的锁 */
pthread_cond_t queue_not_full; /* 当任务队列满时，添加任务的线程阻塞，等待该条件变量满足 */
pthread_cond_t queue_not_empty; /* 任务队列不为空时，通知等待任务的线程 */
pthread_t* threads; /* 存放线程池中，每个线程的tid数组 */
pthread_t adjust_tid; /* 管理者线程的tid */
threadpool_task_t* task_queue; /* 任务队列（数组的首地址） */
/* 线程池信息 */
int min_thr_num; /* 线程池中，最小线程数 */
int max_thr_num; /* 线程池中，最大线程数 */
int live_thr_num; /* 线程池中，存活的线程数 */
int busy_thr_num; /* 忙线程（正在工作的线程）数 */
int wait_exit_thr_num; /* 需要销毁的线程数 */
/* 任务队列信息 */
int queue_front; /* 队头下标 */
int queue_rear; /* 队尾下标 */
int queue_size; /* 队列中，实际的任务数 */
int queue_max_size; /* 队列能容纳的最大任务数 */
/* 状态 */
int shutdown; /* 标志位，线程池的使用状态： true/false */
};
线程数组：
- 本质上是线程池初始化时，申请的的一段存放一堆线程tid的堆空间。
- 这段空间中包含了正在工作的线程、空闲线程（等待工作的线程）、等待被销毁的线程、没有初始化的剩余线程空间（管理者线程会“定时”进行“扩容”和“瘦身”）。
任务队列：
- 存在形式与线程数组相似，线程池初始化时根据传入的最大任务数开辟空间。
- 当服务器前方后请求到来后，分类并打包消息成为任务，将任务放入任务队列并通知空闲线程来取。
/* 任务 */
struct threadpool_task_t {
void*(*function)(void*);
void* arg;
};
任务队列和线程数组的不同：
- 任务队列中，有明显的先后顺序，先进先出
FIFO（用环形队列来模拟）； - 线程数组中，各个线程是竞争关系去拿到互斥锁争取任务；
管理者线程：
- 本质上，就是一个单独的线程，定时检查，来对线程池进行**“扩容”和“瘦身”**；
- 维护线程池平衡的算法，即“扩容”和“瘦身”：
- “扩容”算法（在剩余空间中，创建新的线程）：
存活的线程数 < 最大线程数 && 实际任务数量 >= 最小线程数 - “瘦身”算法（销毁多余的空闲线程）：
存活的线程数 > 最小线程数 && 忙线程x2 < 存活线程
- “扩容”算法（在剩余空间中，创建新的线程）：
整体代码：
thread_pool.h
#ifndef __THREADPOOL_H_
#define __THREADPOOL_H_
#include thread_pool.c
#include MySQL的连接池
关键技术点：
MySQL数据库编程、单例模式、C++11多线程编程、线程互斥、线程同步通信和unique_lock、基于CAS的原子整形、智能指针shared_ptr、lambda表达式、生产者-消费者线程模型
项目源码：
源码及详细说明
项目背景：
在C++开发中，和数据库交互，通常需要以下几个过程：
- TCP三次握手
mysql_connect建立连接- 执行SQL语句
mysql_close释放连接- TCP四次挥手
为了提高MySQL数据库（基于C/S设计）的访问瓶颈，除了在服务器端增加缓存服务器（缓存常用的数据）外（如redis），还可以增加连接池（减小交互过程中，步骤1、2、4、5的时间消耗，以达到连接复用的目的），来提高MySQL Server的访问效率。
在高并发情况下，大量的TCP三次握手、MySQL Server连接认证、MySQL Server关闭连接回收资源、TCP四次挥手，所耗费的性能时间也是很明显的，增加连接池就是为了减少这一部分的性能损耗。
本项目就是为了在C++项目中，提升MySQL Server的访问效率，实现基于C++代码的数据库连接池模块。
连接池功能点介绍：
连接池一般包含了数据库连接所用的ip地址、port端口号、root用户名和password密码以及其它的性能参数，例如initSize初始连接量，maxSize最大连接量，maxIdleTime最大空闲时间、connectionTimeout连接超时时间等，该项目是基于C++语言实现的连接池，主要也是实现以上几个所有连接池都支持的通用基础功能。
- 初始连接量（
initSize）：连接池初始化时会和MySQL Server创建initSize个connection连接。当应用发起MySQL访问时，直接从连接池中获取一个可用的连接即可，使用完成后把当前connection再归还到连接池当中。 - 最大连接量（
maxSize）：当并发访问MySQL Server的请求增多，初始连接量已经不够时，此时需要根据新的请求数量去创建更多的连接给应用去使用，但新创建的连接数量上限是maxSize，不能无限制的创建连接（因为每一个连接都会占用一个socket资源，一般连接池和服务器程序部署在一台主机上，如果连接池占用过多的socket资源，那么服务器就不能接收太多的客户端请求了）。 - 最大空闲时间（
maxIdleTime）：如果在指定的maxIdleTime里面，新增加的连接没有被再次使用过，那么新增加的这些连接资源就要被回收掉，但需要始终保持initSize个初始连接量。 - 连接超时时间（
connectionTimeout）：当MySQL的并发请求量过大，使得连接池中的连接数量已经到达maxSize（没有空闲的连接可使用），故此时应用无法从连接池获取连接，则通过阻塞的方式获取连接。但如果超过connectionTimeout时间，则获取连接失败，无法访问数据库。
该项目主要实现上述的连接池四大功能，可为连接池扩展更多的功能…
功能实现设计：
代码结构：
平台：windows visual studio 2017 x64
ConnectionPool.cpp和ConnectionPool.h：连接池代码实现
Connection.cpp和Connection.h：数据库操作代码、增/删/改/查代码实现
实现要点：
连接的生产和消费，采用“生产者-消费者线程模型”来设计，使用了线程间的同步通信机制“条件变量和互斥锁”。
-
连接池只需要一个实例，所以
ConnectionPool以单例模式进行设计。从ConnectionPool中可以获取和MySQL的连接Connection。 -
空闲连接
Connection全部维护在一个线程安全的Connection队列中，使用线程互斥锁保证队列的线程安全。 -
管理连接池，对其进行**“扩容”和“瘦身”**。
- （生产者线程）扩容：如果
Connection队列空闲连接为空时，还需要再获取连接，则进行“扩容”，但上限数量是maxSize； - （管理者线程 “定时任务”）瘦身：如果
Connection队列空闲连接时间超过maxIdleTime就要被释放掉，但最少保留初始的initSize个连接；
- （生产者线程）扩容：如果
-
如果
Connection队列空闲连接为空，且连接的数量已达上限maxSize，则等待connectionTimeout时间。等待期间，仍无法从Connection队列获取空闲连接，则连接失败，无法访问数据库。 -
用户获取的连接用
shared_ptr(_Ux* _Px, _Dx _deleter)智能指针来管理，用lambda表达式定制连接释放的功能（不是真正释放连接，而是把连接归还到连接池中）。
准备工作：
创建数据库和表：
mysql -u root -p
passwd:******
create datebase chat;
use chat;
create table stuinfo(id int, name varchar(20), age int, sex varchar(10));
alter table stuinfo modify id int primary key auto_increment; # 设置id为该stuinfo表的“主键且自增长”列
创建配置文件mysql.ini：
// 在项目中，创建mysql.ini文件
# 数据库连接池的配置文件，连接的是本地主机localhost:3306的chat数据库
ip=127.0.0.1
port=3306
username=root
password=******
dbname=chat
initSize=10
maxSize=1024
maxIdleTime=60 # 最大空闲时间s
connectionTimeOut=100 # 连接超时时间ms
执行日志log.h：
log.h文件中，定义了一个宏函数LOG(str)，用来打印执行过程中的日志。
#pragma once
#define LOG(str) \
cout << __FILE__ << ":" << __LINE__ << " " << \
__TIMESTAMP__ << " : " << str << endl;
封装与MySQL Server交互操作：
Connection.h
#pragma once
#include Connection.cpp：
#include "pch.h"
#include "log.h"
#include "Connection.h"
#include 测试与mysql的连接并发送插入语句：
#include "pch.h"
#include windows下visual studio遇到的问题：
1、MySQL数据库编程直接采用oracle公司提供的MySQL C/C++客户端开发包，在VS上需要进行相应的头文件和库文件的配置，如下：
- 右键项目 - “属性” - “配置属性” - C/C++ - 常规 - 附加包含目录，填写
mysql.h头文件的路径 - 右键项目 - “属性” - “配置属性” - 链接器 - 常规 - 附加库目录，填写
libmysql.lib的路径 - 右键项目 - “属性” - “配置属性” - 链接器 - 输入 - 附加依赖项，填写
libmysql.lib库的名字 - 把
libmysql.dll动态链接库（Linux下后缀名是.so库）放在工程目录下
2、windows下，visual studio，未定义标识符 “SOCKET”。
/* 解决方法： */
// 1、在 mysql_com.h 文件中，include这两个文件
#include 3、出现fopen/strcpy/sprintf不安全提示：
Error --> 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
/*
解决方法：
使用编译器提供的忽略警告选项：在Visual Studio中，可在项目属性的“C/C++ - 预处理器”中，添加预处理器定义_CRT_SECURE_NO_WARNINGS，从而禁用此警告。
*/
连接池的实现：
ConnectionPool.h：
#pragma once
#include ConnectionPool.cpp：
深入理解c++智能指针：unique_ptr、weak_ptr和shared_ptr（解决交叉引用（即解决存在内存泄露的问题）、线程安全（线程入口函数的形参用weak_ptr，内部将weak_ptr通过lock()方法提升为shared_ptr来判断该块共享内存是否还存在）的问题）。
#include "ConnectionPool.h"
#include "log.h"
// 线程安全的懒汉单例函数接口
ConnectionPool* ConnectionPool::initConnectionPool()
{
static ConnectionPool pool; // lock和unlock
return &pool;
}
// 从配置文件中加载配置项
bool ConnectionPool::loadConfigFile()
{
FILE* pf = fopen("mysql.ini", "r");
if (pf == nullptr)
{
LOG("mysql.ini is not exist!");
return false;
}
while (!feof(pf))
{
char line[1024] = { 0 };
fgets(line, 1024, pf);
string str = line;
int idx = str.find('=', 0);
if (idx == -1) // 无效的配置项
{
continue;
}
int endidx = str.find('\n', idx);
string key = str.substr(0, idx);
string value = str.substr(idx + 1, endidx - idx - 1);
if (key == "ip"){
_ip = value;
} else if (key == "port"){
_port = atoi(value.c_str());
} else if (key == "username"){
_username = value;
} else if (key == "password") {
_password = value;
} else if (key == "dbname") {
_dbname = value;
} else if (key == "initSize") {
_initSize = atoi(value.c_str());
} else if (key == "maxSize") {
_maxSize = atoi(value.c_str());
} else if (key == "maxIdleTime") {
_maxIdleTime = atoi(value.c_str());
} else if (key == "connectionTimeOut") {
_connectionTimeout = atoi(value.c_str());
}
}
return true;
}
// 初始化连接池，并创建生产者线程和管理者线程（定时扫描回收）
ConnectionPool::ConnectionPool()
{
// 从配置文件mysql.ini加载配置项
if (!loadConfigFile())
{
return;
}
// 创建初始数量的connection连接
for (int i = 0; i < _initSize; ++i)
{
Connection* p = new Connection();
p->connect(_ip, _port, _username, _password, _dbname);
p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
_connectionQue.push(p);
_connectionCnt++;
}
// 创建生产者线程produce，执行ConnectionPool::produceConnectionTask()函数
//（注意：linux下，thread => pthread_create）
thread produce(std::bind(&ConnectionPool::produceConnectionTask, this));
produce.detach(); // 设置线程为“分离状态”，自行回收线程资源
// 管理者（定时）线程，扫描超过maxIdleTime时间的空闲连接，并进行连接回收
thread scanner(std::bind(&ConnectionPool::scannerConnectionTask, this));
scanner.detach(); // 设置线程为“分离状态”，自行回收线程资源
}
// 生产者线程：等待cv通知，负责当 _connectionQue.empty() && _connectionCnt < _maxSize 时，生产新连接
void ConnectionPool::produceConnectionTask()
{
for (;;)
{
unique_lock<mutex> lock(_queueMutex);
while (!_connectionQue.empty())
{
/*
wait()/wait_for()：解锁+等待（原子操作）、唤醒和锁定
1）解阻塞时，无关乎原因， lock 再次锁定且 wait()/waitfor() 退出。
2）若此函数通过异常退出，则亦会重获得 lock 。
*/
cv.wait(lock); // 队列不空，此处生产线程进入等待状态
// 被notify_one()/notify_all()唤醒后，继续while循环
}
// 连接数量没有到达上限，继续创建新的连接
if (_connectionCnt < _maxSize)
{
Connection* p = new Connection();
p->connect(_ip, _port, _username, _password, _dbname);
p->refreshAliveTime(); // 刷新一下开始空闲的起始时间
_connectionQue.push(p);
_connectionCnt++;
}
// 通知所有等待的线程
cv.notify_all(); // 通知消费者线程，可以获取（消费）连接
}
}
// 从连接池中，获取一个可用的空闲连接
shared_ptr<Connection> ConnectionPool::getConnection()
{
unique_lock<mutex> lock(_queueMutex);
// wait_for()==cv_status::no_timeout，则表示被唤醒，需要再次判断_connectionQue连接队列是否为空
while (_connectionQue.empty())
{
/*
wait()/wait_for()：解锁+等待（原子操作）、唤醒和锁定
1）解阻塞时，无关缘由，重获得 lock 并退出 wait()/wait_for()。
2）若此函数通过异常退出，则亦重获得 lock 。
在等待的时间_connectionTimeout内，被notify_one()/notify_all()唤醒，则函数立即返回cv_status::no_timeout
否则，一直等到_connectionTimeout时间到了，才能返回cv_status::timeout
*/
if (cv_status::timeout == cv.wait_for(lock, chrono::milliseconds(_connectionTimeout)))
{
if (_connectionQue.empty())
{
LOG("get connection failure because of the timeout!");
return nullptr;
}
}
}
/*
1、默认情况下，shared_ptr智能指针析构时，会把connection资源直接delete掉，相当于调用connection的析构函数
2、这里需要自定义shared_ptr的释放资源的方式，即把connection直接归还到queue当中
shared_ptr的有参构造函数原型：shared_ptr(_Ux* _Px, _Dx _deleter);
*/
shared_ptr<Connection> sp(_connectionQue.front(),
// lambda表达式创建的可调用对象，用作shared_ptr的删除器deleter
[&](Connection* pcon) {
// 这里是在服务器应用线程中调用的，所以一定要考虑队列的线程安全操作
unique_lock<mutex> lock(_queueMutex);
pcon->refreshAliveTime(); // 刷新一下开始空闲的起始时间
_connectionQue.push(pcon);
});
_connectionQue.pop();
// 通知所有等待的线程
cv.notify_all(); // 消费完连接以后，通知生产者线程produceConnectionTask()，继续生产连接，有可能达到最大连接上限maxSize无法再生产
return sp;
}
// 管理者线程，“定时”扫描超过maxIdleTime时间的空闲连接，并进行连接回收
void ConnectionPool::scannerConnectionTask()
{
for (;;)
{
// 通过sleep_for模拟“定时_maxIdleTime”效果
this_thread::sleep_for(chrono::seconds(_maxIdleTime));
// 扫描整个队列，_connectionCnt > _initSize && p->getAliveTime() >= (_maxIdleTime * 1000)，则释放多余的连接
unique_lock<mutex> lock(_queueMutex);
while (_connectionCnt > _initSize)
{
Connection* p = _connectionQue.front();
if (p->getAliveTime() >= (_maxIdleTime * 1000)) // 统一使用毫秒ms为单位
{
_connectionQue.pop();
_connectionCnt--;
delete p; // 调用~Connection()释放连接
}
else
{
break; // 注意：队头的连接没有超过_maxIdleTime，其它连接肯定没有！！！
}
}
}
}
连接池压力测试：
单线程测试：
未使用线程池：
int main_single_thread_unused()
{
clock_t begin = clock();
// 通过修改循环次数，进行测试
for (int i = 0; i < 10000; ++i)
{
Connection conn;
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
conn.update(sql);
}
clock_t end = clock();
cout << (end - begin) << " ms" << endl;
return 0;
}
使用线程池：
int main_single_thread_used()
{
clock_t begin = clock();
ConnectionPool* cp = ConnectionPool::initConnectionPool();
for (int i = 0; i < 10000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
// 当结束一个for循环，sp会被释放，即重新添加到_connectionQue连接队列尾部
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
}
clock_t end = clock();
cout << (end - begin) << "ms" << endl;
return 0;
}
多线程测试：
未使用线程池：
int main_multi_thread_unused()
{
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
clock_t begin = clock();
thread t1([]() {
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
conn.update(sql);
}
});
thread t2([]() {
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
conn.update(sql);
}
});
thread t3([]() {
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
conn.update(sql);
}
});
thread t4([]() {
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
conn.update(sql);
}
});
thread t5([]() {
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
Connection conn;
conn.connect("127.0.0.1", 3306, "root", "211810", "chat");
conn.update(sql);
}
});
// 主线程阻塞等待，四个子线程结束
t1.join(); t2.join(); t3.join(); t4.join(); t5.join();
clock_t end = clock();
cout << (end - begin) << " ms" << endl;
return 0;
}
使用线程池：
int main_multi_thread_used()
{
clock_t begin = clock();
thread t1([]() {
ConnectionPool* cp = ConnectionPool::initConnectionPool();
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
}
});
thread t2([]() {
ConnectionPool* cp = ConnectionPool::initConnectionPool();
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
}
});
thread t3([]() {
ConnectionPool* cp = ConnectionPool::initConnectionPool();
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
}
});
thread t4([]() {
ConnectionPool* cp = ConnectionPool::initConnectionPool();
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
}
});
thread t5([]() {
ConnectionPool* cp = ConnectionPool::initConnectionPool();
for (int i = 0; i < 2000; ++i)
{
char sql[1024] = { 0 };
sprintf(sql, "insert into stuinfo(name,age,sex) values('%s',%d,'%s')", "zhang san", 20, "male");
shared_ptr<Connection> sp = cp->getConnection();
sp->update(sql);
}
});
// 主线程阻塞等待，四个子线程结束
t1.join(); t2.join(); t3.join(); t4.join(); t5.join();
clock_t end = clock();
cout << (end - begin) << " ms" << endl;
return 0;
}
测试结果：
通过插入操作，衡量使用连接池对性能的影响：
| 未使用连接池 | 使用连接池 | |
|---|---|---|
| 2500 | 单线程：2075 ms 五线程：666 ms | 单线程：1128 ms 五线程：377 ms |
| 5000 | 单线程：4003 ms 五线程：1289 ms | 单线程：2216 ms 五线程：712 ms |
| 10000 | 单线程：8110 ms 五线程：2542 ms | 单线程：4365 ms 五线程：1389 ms |
注意：每次测试完，需要用truncate删除表重来，避免主键自增列过大，导致插入失败。
结论：
观察上述结果知，在单线程/多线程的表现下，使用连接池的对性能的提升几乎差不多。
内存池的实现：
为何需要内存池？
- 防止小块内存频繁的分配、释放，造成大量的内存碎片的出现；
- 尤其是当分配大量的小块内存时，内存池对内存的利用率的提升是非常有效的；
分析SGI STL二级空间配置器内存池实现原理：
SGI STL包含了一级空间配置器和二级空间配置器：
- 一级空间配置器
allocator采用malloc和free来管理内存，和C++标准库中提供的allocator是一样的； - 二级空间配置器
allocator采用了基于freelist自由链表原理的内存池机制实现内存管理，且是线程安全的（空间配置器是供容器使用的，而容器的对象可能在多个线程中使用，故需要保证是线程安全的）；
SGI STL内存分配源码
SGI STL的完整源码
空间配置器的相关定义：
这里以SGI STL中vector源码为例：
// 容器的默认空间配置器是__STL_DEFAULT_ALLOCATOR( _Tp)，是一个宏定义
template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class vector : protected _Vector_base<_Tp, _Alloc>
// __STL_DEFAULT_ALLOCATOR( _Tp)是一个宏定义，如下：
# ifndef __STL_DEFAULT_ALLOCATOR
# ifdef __STL_USE_STD_ALLOCATORS
# define __STL_DEFAULT_ALLOCATOR(T) allocator< T > // 一级空间配置器
# else
# define __STL_DEFAULT_ALLOCATOR(T) alloc // 二级空间配置器
# endif
# endif
// 一级空间配置器内存管理类 -- 通过malloc和free管理内存
template <int __inst>
class __malloc_alloc_template;
// 二级空间配置器内存管理类 -- 通过自定义内存池实现内存管理
template <bool threads, int inst>
class __default_alloc_template;
二级空间配置器源码分析：
重要的类型和变量定义：
// 内存池的粒度信息：自由链表从8字节开始，每次增加一倍，直到128字节
enum {_ALIGN = 8};
enum {_MAX_BYTES = 128};
enum {_NFREELISTS = 16};
// 每一个内存chunk块的头信息
union _Obj {
union _Obj* _M_free_list_link;
char _M_client_data[1]; /* The client sees this. */
};
// 组织所有自由链表的数组，数组的每一个元素的类型是_Obj*，全部初始化为0
static _Obj* __STL_VOLATILE _S_free_list[_NFREELISTS];
// Chunk allocation state. 记录内存chunk块的分配情况
static char* _S_start_free;
static char* _S_end_free;
static size_t _S_heap_size;
template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_start_free = 0;
template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_end_free = 0;
template <bool __threads, int __inst>
size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0;
重要的辅助接口函数：
/*将 __bytes 上调至最邻近的 8 的倍数*/
static size_t _S_round_up(size_t __bytes)
{ return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }
/*返回 __bytes 大小的chunk块位于 free-list 中的编号*/
static size_t _S_freelist_index(size_t __bytes)
{ return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1); }
内存池管理函数：
// 分配内存的入口函数
static void* allocate(size_t __n);
/* 极其重要的函数！！！ */
// 分配相应内存字节大小的chunk块，并且给_S_start_free、_S_end_free、_S_heap_size这三个成员变量初始化
static char* _S_chunk_alloc(size_t __size, int& __nobjs);
// 返回一个chunk块，并将剩余分配好的chunk块以“单链表”形式连接，并添加到自由链表中
static void* _S_refill(size_t __n);
// 把chunk块归还到内存池
static void deallocate(void* __p, size_t __n);
// 内存池“扩容/瘦身函数”
template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::reallocate(void* __p, size_t __old_sz, size_t __new_sz);
SGI STL二级空间配置器内存池的优点：
- 对于每一个字节数的
chunk块分配，都分为两部分（一部分使用，另一部分备用），备用部分可给当前字节数使用，也可给其他字节数使用； - 对于备用内存池划分完
chunk块后，如果还有剩余的很小的内存块，再次分配时，会把这些小的内存块再次分配出去，至此备用内存池已使用完； - 指定字节数分配失败后，有一个异常处理过程：对所有的字节的
chunk块进行查看，如果哪个字节数有空闲的，则直接借一个出去； - 如果上述过程还是分配失败，则还会调用一个预先设置好的
malloc内存分配的回调函数oom_malloc。
自实现stl_alloc功能：
项目源码
__malloc_alloc_template.h
#pragma once
#include MyAllocator.h
#pragma once
#include main.cpp
#include nginx的内存池实现原理：
nginx_1.12.2_palloc源码
nginx_1.12.1完成源码的下载地址
nginx内存池源码分析：
- Nginx的内存池模块在
./src/core/ngx_palloc.h和./src/core/ngx_palloc.c文件中，分别定义了“相关的结构体”和“主要函数实现”。 - 注意：
nginx内存池，不用考虑线程安全的问题。
为了保证高可靠性和可用，Nginx不是多线程的，而是多进程的，每个进程独立的创建内存池。 - 为何
Nginx不回收小内存？
- 在时间和空间上取舍，
Nginx觉得小内存本身并不怎么占用空间，且回收还影响速度。 - 另外，它并不作为主进程的内存池，且子进程给每个连接分配的内存池，在连接断开后，大小内存都会回收，并不会造成内存泄露。
内存池的关系图：
重要类型定义：
typedef struct ngx_pool_s ngx_pool_t;
// nginx内存池的主结构体类型（即首个小块内存的头信息）
struct ngx_pool_s {
ngx_pool_data_t d; // 内存块的数据头信息
size_t max; // 小块内存分配的最大值（不能超过一个页面的大小4k），即ngx_pool_data_t可分配的最大内存值，超过此值则使用ngx_pool_large_t分配内存
ngx_pool_t *current; // 小块内存池入口指针
ngx_chain_t *chain; // 挂接一个ngx_chain_t结构
ngx_pool_large_t *large; // 大块内存分配入口指针
ngx_pool_cleanup_t *cleanup; // 清理函数handler的入口指针，释放内存池时的callback函数
ngx_log_t *log; // 日志相关，暂不作研究
};
// 小块内存数据头信息
typedef struct {
u_char *last; // 可分配内存开始位置
u_char *end; // 可分配内存末尾位置
ngx_pool_t *next; // 保存下一个内存池的地址
ngx_uint_t failed; // 记录当前内存池分配失败的次数
} ngx_pool_data_t;
typedef struct ngx_pool_large_s ngx_pool_large_t;
// 大块内存类型定义
struct ngx_pool_large_s {
ngx_pool_large_t *next; // 下一个大块内存
void *alloc; // 记录分配的大块内存的起始地址
};
typedef void (*ngx_pool_cleanup_pt)(void *data); // 清理回调函数的类型定义
typedef struct ngx_pool_cleanup_s ngx_pool_cleanup_t;
// 清理操作的类型定义，包括一个清理回调函数、传给回调函数的数据和下一个清理操作的地址
struct ngx_pool_cleanup_s {
ngx_pool_cleanup_pt handler; // 回调函数指针
void *data; // 传递给回调函数的指针参数
ngx_pool_cleanup_t *next; // 指向下一个回调函数
};
// Nginx内存池支持通过自定义的回调函数，对外部资源的清理。
// ngx_pool_cleanup_t是回调函数结构体，它在内存池中以链表形式保存，在内存池进行销毁时，循环调用这些回调函数对数据进行清理。
重要函数接口：
// 创建内存池
ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log);
// 销毁内存池
void ngx_destroy_pool(ngx_pool_t *pool);
// 重置内存池
void ngx_reset_pool(ngx_pool_t *pool);
// 内存分配函数，支持内存对齐
void *ngx_palloc(ngx_pool_t *pool, size_t size);
// 内存分配函数，不支持内存对齐
void *ngx_pnalloc(ngx_pool_t *pool, size_t size);
// 内存分配函数，支持内存初始化0
void *ngx_pcalloc(ngx_pool_t *pool, size_t size);
// 内存释放（大块内存）
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);
// 得到一个ngx_pool_cleanup_t（其设置handler清理函数、data待清理的数据），并头插入pool->cleanup链表中
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size);
ngx_create_pool创建内存池：
ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log)
{
// 为当前内存池分配第一块内存
ngx_pool_t *p;
// 调用nginx的字节对齐内存分配函数，为p分配size大小的内存块
p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
if (p == NULL) {
return NULL;
}
// last跨过内存块中ngx_pool_t结构体，指向紧接着的可分配内存的起始位置
p->d.last = (u_char *) p + sizeof(ngx_pool_t);
// end指向当前size大小内存块的末尾
p->d.end = (u_char *) p + size;
p->d.next = NULL;
p->d.failed = 0;
// 该语句执行后，size为该内存块可分配的内存大小
size = size - sizeof(ngx_pool_t);
/*
#define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize - 1)
即x86中，页大小为4K，内存池最大不超过4095
*/
p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
p->current = p;
p->chain = NULL;
p->large = NULL;
p->cleanup = NULL;
p->log = log;
return p;
}
// `alignment`主要是针对部分`unix`平台需要动态的对齐，大多数情况下编译器和C库都会帮我们处理对齐问题。
#define ngx_memalign(alignment, size, log) ngx_alloc(size, log)
void *ngx_alloc(size_t size, ngx_log_t *log)
{
void *p = malloc(size);
if (p == NULL) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "malloc(%uz) failed", size);
}
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);
return p;
}
ngx_palloc内存分配函数（支持内存对齐）：
// 在内存分配时，针对用户所申请的内存的大小，分别“小内存”和“大内存”两种分配策略。
void *ngx_palloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
if (size <= pool->max) {
return ngx_palloc_small(pool, size, 1);
}
#endif
return ngx_palloc_large(pool, size);
}
ngx_palloc_small小块内存分配
// 申请小块内存，遍历pool->next链表，判断各内存块是否有满足的可分配空间
// 有则直接分配，否则需要重新申请一个小内存块
static ngx_inline void *ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
{
u_char *m;
ngx_pool_t *p;
// 从首个内存块开始寻找
p = pool->current;
do {
m = p->d.last;
// 对齐处理
if (align) {
/*
// 小块内存分配考虑字节对齐时的单位
#define NGX_ALIGNMENT sizeof(unsigned long) // platform word
#define ngx_align_ptr(p, a) (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
*/
m = ngx_align_ptr(m, NGX_ALIGNMENT);
}
// 当前内存块的剩余内存 >= 所需内存
if ((size_t) (p->d.end - m) >= size) {
// 分配内存，并将last指针移向新位置
p->d.last = m + size;
return m;
}
// 当前内存块的剩余内存 < 所需内存，则去下一个内存块中寻找
p = p->d.next;
} while (p);
// 遍历所有内存块，都没有合适的内存空间，则需分配新的内存块
return ngx_palloc_block(pool, size);
}
// 向系统申请新的内存块，满足failed机制情况下，将其添加到链表（头结点为首个内存块中的next）“尾部”
static void *ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
u_char *m;
size_t psize;
ngx_pool_t *p, *new;
// 计算首个内存块的大小
psize = (size_t) (pool->d.end - (u_char *) pool);
// 为新的内存块分配psize大小的内存块
m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
if (m == NULL) {
return NULL;
}
// 将申请的内存块指针转换为ngx_pool_t指针
new = (ngx_pool_t *) m;
// 初始化新内存块ngx_pool_data_t中，end、next和faile字段
new->d.end = m + psize;
new->d.next = NULL;
new->d.failed = 0;
// 指针m移动到可分配内存的开始位置，即需要排除掉ngx_pool_data_t结构体字段占用的内存
m += sizeof(ngx_pool_data_t);
// 通过移动m指针，进行对齐处理
/*
#define NGX_ALIGNMENT sizeof(unsigned long)
#define ngx_align_ptr(p, a) (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
*/
m = ngx_align_ptr(m, NGX_ALIGNMENT);
// 分配size字节后，则新内存块的last指向剩余可用内存空间的首地址
new->d.last = m + size;
/* failed的控制机制，保证前面的内存块基本处于満的状态，仅剩余部分小块区域。*/
// “尾插”：找到pool->next为头结点的链表的最后一个节点，并将new挂在其后
for (p = pool->current; p->d.next; p = p->d.next) {
// 在以pool->next为头结点的链表中，某个内存块的failed次数超过4次，则调整首个内存块为其后的内存块（即“之前的内存块不能再参与分配”）
if (p->d.failed++ > 4) { // 各个内存块，一旦遍历到这里就需要对其failed字段加一
pool->current = p->d.next;
}
}
p->d.next = new;
return m;
}
ngx_palloc_large大块内存分配：
/*
申请大于max的内存块，分配内存后：
1、放入链表前三个中，有空闲的alloc中
2、否则，将重新申请一个ngx_pool_large_t后将其放入alloc，并其“头插”到大块内存链表（头结点为pool->large）中
*/
static void *ngx_palloc_large(ngx_pool_t *pool, size_t size)
{
void *p;
ngx_uint_t n;
ngx_pool_large_t *large;
// 向系统申请一块size大小的内存空间
p = ngx_alloc(size, pool->log); // ngx_alloc函数内部封装着malloc
if (p == NULL) {
return NULL;
}
n = 0;
// 在以首个内存块中large为头结点的链表中，ngx_pool_large_t结构体的alloc为空的节点
// 如果有，则将刚才分配的空间交由它管理
for (large = pool->large; large; large = large->next) {
if (large->alloc == NULL) {
large->alloc = p;
return p;
}
// 为提高效率，如果查找3次仍未找到，则直接跳出循环直接创建
if (n++ > 3) {
break;
}
}
// 此处，本质上会去调用ngx_palloc_small函数
large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
if (large == NULL) {
ngx_free(p);
return NULL;
}
large->alloc = p;
// 大块内存的指针”头插“到以pool->large为头节点的链表中
large->next = pool->large;
pool->large = large;
return p;
}
结合该大块内存分配函数，可修正nginx内存池的关系图：
ngx_pfree内存释放：
- 大块内存的释放：
ngx_pfree函数，内部仅仅对指定的大块内存进行释放。- 因为大内存块的分配，只检查前3个内存块（考虑效率问题）中
alloc是否指向NULL，否则就直接分配内存，所以大内存块的释放必须及时。
- 小块内存的处理：
nginx内存池手动申请的小块内存，在该内存池中并不提供相应小块内存的释放操作，小块内存的分配是通过last指针的偏移完成的。
nginx内存池和SGI STL内存池的使用场景分析：
-
nginx主要用于http服务器，即短链接的服务器（客户端发起请求，服务端处理后nginx给客户端发送响应，之后会主动断开tcp连接（http 1.1之后，keep-alive：60s后，期间不再收到客户端请求才能断开tcp连接，否则重置该时间））此时nginx可调用ngx_reset_pool重置内存池，并等待下一次连接…弊端：如果是长链接的话，不断地通信会逐渐申请小块内存，但并未真正释放，则最终会将内存耗尽。
-
如果是
tcp长链接，则需要采用SGI STL中的二级空间配置器，每次处理完立即释放连接所占的内存空间。虽然其也可用于短链接，但由于需要释放，故效率低于nginx内存池。
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p)
{
ngx_pool_large_t *l;
// 遍历并将pool->large指向的大块内存链表，全部释放
for (l = pool->large; l; l = l->next) {
if (p == l->alloc) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
ngx_free(l->alloc); // 本质上就是free()
l->alloc = NULL;
return NGX_OK;
}
}
return NGX_DECLINED;
}
ngx_reset_pool内存池重置：
// 重置，即将内存池中的大块内存链表、小块内存链表内的可分配内存空间全部释放出来
void ngx_reset_pool(ngx_pool_t *pool)
{
ngx_pool_t *p;
ngx_pool_large_t *l;
// 将pool->large指向的大块内存链表，全部释放
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
// 重置小块内存：并不调用free将内存交还给系统，只是指针的复位操作
/*
// 源码提供的重置小块内存的方法：没有考虑内存池中除了首个内存块外，其余的内存块的头信息只是ngx_pool_data_t结构体，故会造成一定的空间浪费
for (p = pool; p; p = p->d.next) {
p->d.last = (u_char *) p + sizeof(ngx_pool_t);
p->d.failed = 0;
}*/
/* 优化后：*/
// 1、重置内存池中，首个内存块
p = this->_pool;
p->d.last = (u_char *) p + sizeof(ngx_pool_t);
p->d.failed = 0;
// 2、重置内存池中，其他的内存块
for (p = pool; p; p = p->d.next) {
p->d.last = (u_char *) p + sizeof(ngx_pool_data_t);
p->d.failed = 0;
}
pool->current = pool;
pool->chain = NULL;
pool->large = NULL;
}
ngx_destroy_pool销毁内存池：
// 得到一个ngx_pool_cleanup_t（其设置handler清理函数、data待清理的数据），并头插入pool->cleanup链表中
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
ngx_pool_cleanup_t *c;
c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
if (c == NULL) {
return NULL;
}
if (size) {
c->data = ngx_palloc(p, size);
if (c->data == NULL) {
return NULL;
}
} else {
c->data = NULL;
}
c->handler = NULL;
// 头插
c->next = p->cleanup;
p->cleanup = c;
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, p->log, 0, "add cleanup: %p", c);
return c;
}
内存池的销毁操作中，该函数会循环调用ngx_pool_cleanup_s中的handler函数释放资源，并释放大块内存和小块内存链表的内存块。
ngx_destroy_pool(ngx_pool_t *pool)
{
ngx_pool_t *p, *n;
ngx_pool_large_t *l;
ngx_pool_cleanup_t *c;
// 循环调用handler清理函数
for (c = pool->cleanup; c; c = c->next) {
if (c->handler) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"run cleanup: %p", c);
c->handler(c->data);
}
}
// 释放大块内存
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
// 释放所有内存池中的小块内存
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_free(p);
if (n == NULL) {
break;
}
}
}
测试用例：
环境配置：
运行在centos 7上，且需要提前解压tar -zxvf nginx-1.16.0.tar.gz后，./configure，之后make编译nginx源码。
test_ngx_memoryPool.c
#include 编译连接命令：
// compile: where is include files
gcc -c ngx_testpool.c -o ngx_testpool.o -g -I /opt/nginx-1.16.0/src/core -I /opt/nginx-1.16.0/src/event -I /opt/nginx-1.16.0/src/event/modules -I /opt/nginx-1.16.0/src/os/unix -I /opt/nginx-1.16.0/objs -I /opt/nginx-1.16.0/src/http -I src/http/modules
// dynamic link:
gcc -o ngx_testpool ngx_testpool.o /opt/nginx-1.16.0/objs/src/core/ngx_palloc.o /opt/nginx-1.16.0/objs/src/os/unix/ngx_alloc.o
自实现nginx_palloc的功能：
项目源码
完全按照nginx源码的内存分配策略实现。
ngx_memoryPool.h
#pragma once
// 类型重定义：
using u_char = unsigned char;
using ngx_uint_t = unsigned int;
// 一个页的大小4K
# define ngx_pagesize 4096
// 小块内存能分配的最大的大小
#define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize - 1)
// 默认nginx内存池开辟的大小为16K
#define NGX_DEFAULT_POOL_SIZE (16 * 1024)
// 内存池大小按照16bytes进行内存对齐
#define NGX_POOL_ALIGNMENT 16
// 将小块内存最小的size，调整为NGX_POOL_ALIGNMENT临近的倍数
#define NGX_MIN_POOL_SIZE ngx_align((sizeof(ngx_pool_t) + 2 * sizeof(ngx_pool_large_t)), NGX_POOL_ALIGNMENT)
// 小块内存分配考虑字节对齐时的单位
#define NGX_ALIGNMENT sizeof(unsigned long) /* platform word */
// 将数值x调整到数值y的临近的倍数
#define ngx_align(x, y) (((x) + (y - 1)) & ~(y - 1))
// 将指针p内存对齐到a的临近的倍数
#define ngx_align_ptr(p, a) (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
// 将buf缓冲区置为0/c
#define ngx_memzero(buf, n) (void) memset(buf, 0, n)
#define ngx_memset(buf, c, n) (void) memset(buf, c, n)
struct ngx_pool_t;
/* 小块内存数据头信息 */
struct ngx_pool_data_t {
u_char* last; // 可分配内存开始位置
u_char* end; // 可分配内存末尾位置
ngx_pool_t* next; // 保存下一个内存池的地址
size_t failed; // 记录当前内存池分配失败的次数
};
/* 大块内存数据头信息 */
struct ngx_pool_large_t {
ngx_pool_large_t *next; // 下一个大块内存
void *alloc; // 记录分配的大块内存的起始地址
};
typedef void(*ngx_pool_cleanup_pt)(void*data); // 清理回调函数的类型定义
/*
清理操作的类型定义：
1、Nginx内存池支持通过自定义的回调函数，对外部资源的清理。
2、ngx_pool_cleanup_t是回调函数结构体，它在内存池中以链表形式保存，在内存池进行销毁时，循环调用这些回调函数对数据进行清理。
*/
struct ngx_pool_cleanup_t {
ngx_pool_cleanup_pt handler; // 清理回调函数指针
void *data; // 传递给回调函数的参数
ngx_pool_cleanup_t *next; // 指向下一个清理回调函数
};
/* nginx内存池的主结构体类型（即首个小块内存的头信息）*/
struct ngx_pool_t {
ngx_pool_data_t d; // 内存块的数据头信息
size_t max; // 小块内存分配的最大值（不能超过一个页面的大小4K），即ngx_pool_data_t可分配的最大内存值，超过此值则使用ngx_pool_large_t分配内存
ngx_pool_t* current; // 小块内存池入口指针
ngx_pool_large_t* large; // 大块内存分配入口指针
ngx_pool_cleanup_t* cleanup; // 清理函数handler的入口指针，释放内存池时的callback函数
};
class ngx_memoryPool
{
public:
// 创建size大小的内存池
bool ngx_create_pool(size_t size);
// 从内存池中分配size大小的内存，支持内存对齐
void* ngx_palloc(size_t size);
// 从内存池中分配size大小的内存，不支持内存对齐
void* ngx_pnalloc(size_t size);
// 从内存池中分配size大小的内存，支持内存初始化0
void* ngx_pcalloc(size_t size);
// 大块内存释放、小块内存只做指针移动调整
void ngx_pfree(void* p);
// 得到一个ngx_pool_cleanup_t，将其设置handler清理函数、data待清理的数据
ngx_pool_cleanup_t *ngx_pool_cleanup_add(size_t size);
// 销毁内存池
void ngx_destroy_pool();
// 重置内存池，即将内存池中的大块内存链表、小块内存链表内的可分配内存空间全部释放出来
void ngx_reset_pool();
private:
ngx_pool_t* _pool;
/* 内存分配的机制：小块、大块内存的分配 */
/*
申请小块内存，遍历pool->next链表，判断各内存块是否有满足的可分配空间：
有则直接分配，否则需要重新申请一个小内存块
*/
void* ngx_palloc_small(size_t size, ngx_uint_t align);
// 向系统申请新的内存块，满足failed机制情况下，将其添加到链表（头结点为首个内存块中的next）“尾部”
void* ngx_palloc_block(size_t size);
/*
申请大于max的大块内存：
1、遍历大块内存链表（头结点为pool->large），判断是否存在节点的alloc==NULL的情况，有则将申请的内存块存放在该节点
2、否则，加入大块内存链表（头结点为pool->large）尾部
*/
void* ngx_palloc_large(size_t size);
};
ngx_memoryPool.cpp
#include main.cpp
#include