Nginx内存池理解

　　工作中经常遇到内存泄漏，而且又很难排查是哪里没有释放导致，如果采用内存池的方式，内存都从内存池里面分配，销毁内存池时才统一释放，就能减少很多的内存泄漏问题。使用内存池的意义，一个是能够有效解决内存碎片化的问题，再一个就是避免内存泄漏的问题；本文主要介绍Nginx的内存池。

　　（1）Nginx内存池结构

　　　　大块结构定义

?

1 2 3 4 5

//大块 struct ngx_pool_large_s {     ngx_pool_large_t     *next;//下一个大块内存     void                 *alloc;//分配的大块内存空间 };

　　ngx_pool_data_t 结构定义

?

1 2 3 4 5 6 7

//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;<br>//申请小块内存都会在chunck里面分配

　　内存池结构定义

?

1 2 3 4 5 6 7 8 9

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）创建内存池

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

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）销毁内存池

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

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值进行重置。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

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中进行小块分配，否则就到大块去分配。

?

1 2 3 4 5 6 7 8 9 10

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中进行小块分配，否则就到大块去分配。

?

1 2 3 4 5 6 7 8 9 10

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

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中可分配内存的起始地址

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

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节点，该节点指向大块链表的头节点，这么做是便于统一管理，减少内存碎片化

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

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; }