Nginx内存池理解
工作中经常遇到内存泄漏，而且又很难排查是哪里没有释放导致，如果采用内存池的方式，内存都从内存池里面分配，销毁内存池时才统一释放，就能减少很多的内存泄漏问题。使用内存池的意义，一个是能够有效解决内存碎片化的问题，再一个就是避免内存泄漏的问题；本文主要介绍Nginx的内存池。
（1）Nginx内存池结构
大块结构定义
//大块
struct ngx_pool_large_s {
ngx_pool_large_t *next;//下一个大块内存
void *alloc;//分配的大块内存空间
};
ngx_pool_data_t 结构定义
//ngx_pool_data_t可以理解为是嵌入到ngx_pool_s里
typedef struct {
u_char *last;//内存块中last指向还没有用过的内存的头部地址，也可以认为分配的小块内存就是指针last的移动
u_char *end;//当前chunck的末尾
ngx_pool_t *next;//指向下一个chunck
ngx_uint_t failed;//统计该内存池不能满足分配请求的次数
} ngx_pool_data_t;
//申请小块内存都会在chunck里面分配
内存池结构定义
struct ngx_pool_s {
ngx_pool_data_t d;//chunck链表
size_t max;//chunck内存最大大小
ngx_pool_t *current;
ngx_chain_t *chain;//可以挂载一个chain结构
ngx_pool_large_t *large;//大块链表
ngx_pool_cleanup_t *cleanup;//挂载一些内存池释放的时候，同时释放的资源
ngx_log_t *log;
};
大块的链表结构：
内存池结构：
由上图可知，小块内存是在chunck里面分配，end指针指向的是整个chunck的尾部，last指针指向未使用的内存首部地址（分配内存开始位置），为了方便统一管理，large节点是放在chunck里面，它指向大块的链表。
（2）创建内存池
ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log)//size为chunck的大小
{
ngx_pool_t *p;
p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);//分配一块size大小，不同系统会不一样
if (p == NULL) {
return NULL;
}
p->d.last = (u_char *) p + sizeof(ngx_pool_t);//指向一个ngx_pool_t尾部，即指向可以分配内存的起始地址
p->d.end = (u_char *) p + size;//指向整个内存块的尾部地址
p->d.next = NULL;
p->d.failed = 0;
size = size - sizeof(ngx_pool_t);//减去头部，就是可分配的大小
p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;//最大不超过NGX_MAX_ALLOC_FROM_POOL
p->current = p;//指向当前的内存池
p->chain = NULL;
p->large = NULL;
p->cleanup = NULL;
p->log = log;
return p;
}
（3）销毁内存池
void ngx_destroy_pool(ngx_pool_t *pool)
{
ngx_pool_t *p, *n;
ngx_pool_large_t *l;
ngx_pool_cleanup_t *c;
//先遍历cleanup链表，调用函数去删除数据,这是对自己指定的数据进行清理，如果没挂载有就不执行
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);
}
}
#if (NGX_DEBUG)
/*
* we could allocate the pool->log from this pool
* so we cannot use this log while free()ing the pool
*/
for (l = pool->large; l; l = l->next) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
}
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"free: %p, unused: %uz", p, p->d.end - p->d.last);
if (n == NULL) {
break;
}
}
#endif
//大块清理
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
//chunck清理
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_free(p);
if (n == NULL) {
break;
}
}
}
（4）重置内存池
释放所有大块内存，将所有chunck的last指针、failed值进行重置。
void ngx_reset_pool(ngx_pool_t *pool)
{
ngx_pool_t *p;
ngx_pool_large_t *l;
//释放所有的大块内存（大块的链表节点依然还在，因为它存储在chunck里面）
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
//将chunck中last指针初始化，chunck内存中的数据不需要清理，后面分配时覆盖
for (p = pool; p; p = p->d.next) {
p->d.last = (u_char *) p + sizeof(ngx_pool_t);//指向分配内存的起始地址
p->d.failed = 0;//置0
}
pool->current = pool;
pool->chain = NULL;
pool->large = NULL;
}
（5）分配内存
ngx_palloc 分配的内存是对齐的，如果分配的内存小于chunck的大小，就到chunck中进行小块分配，否则就到大块去分配。
void * ngx_palloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
if (size <= pool->max) {//小于chunck最大大小，就分配到chunck中(小块)
return ngx_palloc_small(pool, size, 1);//1：内存对齐
}
#endif
//否则，分配到大块中
return ngx_palloc_large(pool, size);
}
ngx_pnalloc 分配的内存是不对齐的，如果分配的内存小于chunck的大小，就到chunck中进行小块分配，否则就到大块去分配。
void * ngx_pnalloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
if (size <= pool->max) {
return ngx_palloc_small(pool, size, 0);//0：内存不对齐
}
#endif
return ngx_palloc_large(pool, size);
}
（6）ngx_palloc_small小块分配
从当前chunck开始遍历，如果当前chunck有足够空间可分配，那么就返回可分配的起始地址
当遍历完所有chunck都找不到可分配的空间，则新建一个chunck
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;//指向当前chunck块中还未分配的首位地址
if (align) {
m = ngx_align_ptr(m, NGX_ALIGNMENT);//对齐内存指针，加快存取速度
}
//如果当前chunck有足够空间可分配，那么就返回内存可分配的起始地址
if ((size_t) (p->d.end - m) >= size) {
p->d.last = m + size;
return m;//返回可分配的内存地址
}
p = p->d.next;//指向下一chunck
} while (p);
//遍历完所有chunck都找不到可分配的空间，则需要新建一个chunck，返回该chunck可分配的起始地址
return ngx_palloc_block(pool, size);
}
（7）ngx_palloc_block 新建一个chunck
新建一个chunck过程与新建内存池相似，从内存中取一块地址分配一个chunck，进行内存对齐
最后返回chunck中可分配内存的起始地址
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);//去除头部后，得到真正使用的内存空间大小，一个chunck可用空间大小
//分配一块psize大小的内存，返回可用空间的起始地址
m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
if (m == NULL) {
return NULL;
}
new = (ngx_pool_t *) m;
new->d.end = m + psize;//整个chunck的大小
new->d.next = NULL;
new->d.failed = 0;
m += sizeof(ngx_pool_data_t);
//进行内存对齐
m = ngx_align_ptr(m, NGX_ALIGNMENT);
new->d.last = m + size;
for (p = pool->current; p->d.next; p = p->d.next) {
if (p->d.failed++ > 4) {//如果failed > 4, 漏过这个chunck(也就是说每个块，只允许失败4次，失败4次后，让current指向下一个chunck)
pool->current = p->d.next;
}
}
//把chunck插入链表尾部
p->d.next = new;
return m;
}
（8）ngx_palloc_large 大块分配
从申请一块size大小的内存，大于3使用尾插法，大于3使用头插法
在chunck里面分配一个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);
if (p == NULL) {
return NULL;
}
n = 0;
for (large = pool->large; large; large = large->next) {
//n小于3使用尾插法
if (large->alloc == NULL) {//找到最后一个节点
large->alloc = p;//指向分配的内存块
return p;
}
if (n++ > 3) {//大于3使用头插法，好处就是查找最近插入点的效率快很多，3可能是经验值
break;
}
}
//在chunck里分配一个链表的节点（用于指向大块），这个节点是存放在小块里，原因是避免内存碎片化，便于统一管理
large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
if (large == NULL) {
ngx_free(p);
return NULL;
}
//头插法
large->alloc = p;
large->next = pool->large;
pool->large = large;
return p;
}
