struct ngx_pool_s {
ngx_pool_data_t d; // 指向内存池的第一个数据块
size_t max; // 内存池数据块的最大值(数目)
ngx_pool_t *current; // 指向当前内存池
ngx_chain_t *chain; // 该指针挂接一个ngx_chain_t结构
ngx_pool_large_t *large; // 大块内存链表，即分配空间超过max的内存
ngx_pool_cleanup_t *cleanup; // 释放内存池的callback
ngx_log_t *log; // 主要用于记录日志信息
};
大块内存：
struct ngx_pool_large_s {
ngx_pool_large_t *next; // 指向下一个large内存
void *alloc; // 指向分配的large内存
};
回收站：
struct ngx_pool_cleanup_s {
ngx_pool_cleanup_pt handler; // 指向用于cleanup本cleanup内存
void *data; // 指向分配的cleanup内存
ngx_pool_cleanup_t *next; // 指向下一个cleanup内存
};
ngx_pool_t 的逻辑结构：
ngx_create_pool 创建内存池
用于创建一个内存池，我们创建时，传入我们的初始大小：
#define ngx_memalign(alignment, size, log) ngx_alloc(size, log)
//ngx_alloc：对malloc进行了简单封装
ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log)
{
ngx_pool_t *p;
p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
if (p == NULL) {
return NULL;
}
// 可以看到 last 指向 pool 之后的位置，即下一个pool块分配的位置
p->d.last = (u_char *) p + sizeof(ngx_pool_t);
// end 指向pool的size的最后，即当前pool可容纳的最大尺寸的结束位置
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;
/*
nginx对内存的管理分为大内存与小内存，
当某一个申请的内存大于某一个值时，就需要从大内存中分配空间，否则从小内存中分配空间。
nginx中的内存池是在创建的时候就设定好了大小，
在以后分配小块内存的时候，如果内存不够，则是重新创建一块内存串到内存池中，而不是将原有的内存池进行扩张。
当要分配大块内存时，则是在内存池外面再分配空间进行管理的，称为大块内存池。
*/
p->current = p;
p->chain = NULL;
p->large = NULL;
p->cleanup = NULL;
p->log = log;
return p;
}
ngx_destroy_pool 销毁内存池
void ngx_destroy_pool(ngx_pool_t *pool)
{
ngx_pool_t *p, *n;
ngx_pool_large_t *l;
ngx_pool_cleanup_t *c;
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) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, “free: %p”, l->alloc);
if (l->alloc) {
ngx_free(l->alloc);
}
}
#if (NGX_DEBUG)
… …
#endif
for (p = pool, n = pool->d.next; ; p = n, n = n->d.next) {
ngx_free§;
if (n == NULL) {
break;
}
}
}
遍历内存池链表，释放所有内存，包括pool，large，cleanup链表，如果指定了cleanup回调来释放，则调用cleanup的handler来释放cleanup链表中的内存。
先依次释放pool中cleanup，large类型的链表，最后释放pool本身的链表。
ngx_reset_pool 重置内存池
void ngx_reset_pool(ngx_pool_t *pool)
{
ngx_pool_t *p;
ngx_pool_large_t *l;
// 先遍历large链表，释放large内存
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
pool->large = NULL;
//重置所有小块内存区
for (p = pool; p; p = p->d.next) {
p->d.last = (u_char *) p + sizeof(ngx_pool_t);
}
}
ngx_palloc 分配内存
ngx_align_ptr：一个用来内存地址取整的宏。取整可以降低CPU读取内存的次数，提高性能。这里并没有真正意义调用malloc等函数申请内存，而是移动指针标记而已，所以内存对齐的活，得自己动手。
#define ngx_align_ptr(p, a) \
(u_char *) (((uintptr_t) § + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
void *ngx_palloc(ngx_pool_t *pool, size_t size)
{
u_char *m;
ngx_pool_t *p;
if (size <= pool->max) { // 如果需要分配的size大于max，则使用palloc_large来分配
p = pool->current; // 小于max，则从current开始遍历pool链表
do {
// 每次从last处开始分配aligned内存
m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);
if ((size_t) (p->d.end - m) >= size) {
// 如果分配的内存够用，则就从此处分配，并调整last
p->d.last = m + size;
return m;
}
p = p->d.next;
} while §;
// 表示链表里没有能够分配size大小的内存节点
// 则生成一个新的节点，并在其中分配内存
return ngx_palloc_block(pool, size);
}
// 大于max的，就在large中进行分配
return ngx_palloc_large(pool, size);
}
static void *ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
u_char *m;
size_t psize;
ngx_pool_t *p,*new,*current;
psize = (size_t) (pool->d.end - (u_char *) pool);//计算内存池第一个内存块的大小
m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);//分配和第一个内存块同样大小的内存块
if (m == NULL) {
return NULL;
}
new = (ngx_pool_t *) m;
new->d.end = m + psize;//设置新内存块的end
new->d.next = NULL;
new->d.failed = 0;
m += sizeof(ngx_pool_data_t);//将指针m移动到d后面的一个位置，作为起始位置
m = ngx_align_ptr(m, NGX_ALIGNMENT);//对m指针按4字节对齐处理
new->d.last = m + size;//设置新内存块的last，即申请使用size大小的内存
current = pool->current;
//这里的循环用来找最后一个链表节点，这里failed用来控制循环的长度，如果分配失败次数达到5次，
//就忽略，不需要每次都从头找起
for (p = current; p->d.next; p = p->d.next) {
if(p->d.failed++ > 4) { //这儿咋总觉得哪里怪怪的
current = p->d.next;
}
}
p->d.next = new;
pool->current = current ? current : new;
return m;
}
ngx_palloc_large：开辟一个大内存检查后交给大内存链表管理。所以开辟的内存必定在大内存链表上。
/*
-
1）判断pool->large链表上查询是否有NULL的，只在链表上往下查询3次，主要判断大数据块是否有被释放的，有就给它赋值，如果没有则只能跳出。
-
2）然后往下新创建一个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;
p = ngx_alloc(size, pool->log);//注意该函数是单独调用malloc，所以它的内存与内存池链表的内存是不连续的或者叫无关。
if (p == NULL) {
return NULL;
}
n = 0;
// 1）判断pool->large链表上查询是否有NULL的，只在链表上往下查询3次，主要判断大数据块是否有被释放的，有就给它赋值，如果没有则只能跳出
for (large = pool->large; large; large = large->next) {
if (large->alloc == NULL) {
large->alloc = p;
return p;
}
if (n++ > 3) {
break;
}
}
// 2）新建pool->large结构体管理新内存，注意：是创建结构体的大小，属于小内存块(不要以为调用ngx_palloc_small后会造成递归调用)
large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
if (large == NULL) {
ngx_free§;
return NULL;
}
large->alloc = p;//刚开辟的内存交给pool->large链表管理
large->next = pool->large;//插入新的pool->large结构体。注：插法是每次新的pool->large结构体插进第一个pool->large的后面。即pool->large->la3->la2->la1->NULL
pool->large = large;
return p;
}
ngx_pfree 内存清理
/**
-
指定释放大内存块链表的某一块大内存。
-
这里可以看到大内存的管理是支持释放某一块大内存的，所以上面的ngx_palloc_large函数每一次都检查前三个是否为空，
-
确保前三个有内存空间可用，至于后面是否为空就只能不怎么关心了。
*/
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p)
{
ngx_pool_large_t *l;
//遍历大内存链表，若找到想要释放的大内存则释放，否则返回错误NGX_DECLINED
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);
l->alloc = NULL;
return NGX_OK;
}
}
return NGX_DECLINED;
}
cleanup机制
pool->cleanup本身是一个链表，每个ngx_pool_cleanup_t的数据结构上，保存着内存数据的本身cleanup->data和回调清理函数cleanup->handler。
ngx_pool_cleanup_add：分配一个可以用于回调函数清理内存块的内存。内存块仍旧在p->d或p->large上(因为调用的是ngx_palloc)
/**
-
1）创建一个新的ngx_pool_cleanup_t结构体并给其内部成员开辟内存空间。
-
2）使用头插法将新的结构体插入清理链表。
-
注意：初始化时回调c->handler设为NULL，并且返回值为返回当前结构体，所以该内存可以由用户自定义并且自行处理，非常灵活。
-
实际上该函数注意是用来添加以下两个内容：
-
- 文件描述符
-
- 外部自定义回调函数可以来清理内存
*/
*/
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
ngx_pool_cleanup_t *c;
// 1）创建新的清理结构体和开辟空间
c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
if (c == NULL) {
return NULL;
}
if (size) {
c->data = ngx_palloc(p, size);//该函数调用samll或者large，所以内存块仍旧在p->d或p->large上
if (c->data == NULL) {
return NULL;
}
} else {
c->data = NULL;
}
// 2）使用头插法插入清理链表，并且回调设为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_run_cleanup_file：清除p->cleanup链表上的某个已打开的文件描述符fd占用的内存块（或者叫清除指定的文件描述符）
void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd) {
ngx_pool_cleanup_t *c;
ngx_pool_cleanup_file_t *cf;
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
最后
看完上述知识点如果你深感Java基础不够扎实，或者刷题刷的不够、知识不全面
小编专门为你量身定制了一套<Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法>
针对知识面不够，也莫慌！还有一整套的<Java核心进阶手册>，可以瞬间查漏补缺
全都是一丢一丢的收集整理纯手打出来的
更有纯手绘的各大知识体系大纲，可供梳理：Java筑基、MySQL、Redis、并发编程、Spring、分布式高性能架构知识、微服务架构知识、开源框架知识点等等的xmind手绘图~
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！**
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）
最后
看完上述知识点如果你深感Java基础不够扎实，或者刷题刷的不够、知识不全面
小编专门为你量身定制了一套<Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法>
[外链图片转存中…(img-B1jqZdZA-1713533695050)]
针对知识面不够，也莫慌！还有一整套的<Java核心进阶手册>，可以瞬间查漏补缺
[外链图片转存中…(img-wNND93Rq-1713533695051)]
全都是一丢一丢的收集整理纯手打出来的
更有纯手绘的各大知识体系大纲，可供梳理：Java筑基、MySQL、Redis、并发编程、Spring、分布式高性能架构知识、微服务架构知识、开源框架知识点等等的xmind手绘图~
[外链图片转存中…(img-87kxUkxP-1713533695052)]
[外链图片转存中…(img-OnatiPmH-1713533695053)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
