别看Nginx外表高冷，肚子里的动态数组却是个灵活的小胖子
01 为什么Nginx要自己造轮子？
当你第一次打开Nginx源码，可能会被它那密密麻麻的自定义数据结构吓到。放着标准的C++ STL不用，为什么要费这么大劲自己实现一套？
这得从Nginx的应用场景说起。
想象一下，你正在设计一个每天要处理数百万请求的高性能服务器。每个请求都需要快速分配内存，处理完毕后又得立即释放，像春运期间的车站，人潮汹涌却秩序井然。
在这种场景下，通用数据结构就像瑞士军刀，功能全面但效率欠佳；而Nginx的自定义数据结构则是专业手术刀，为特定场景精心优化。
Nginx动态数组ngx_array_t就是这样一把手术刀，它融合了C数组的性能和动态数组的灵活性，同时深度集成Nginx的内存池，实现了极致效率。
与C++的vector不同，ngx_array_t直接构建在Nginx内存池之上，这使得它在频繁分配释放的场景下表现卓越，避免了频繁调用malloc/free的性能损耗。
02 解剖ngx_array_t：小身板里的大智慧
ngx_array_t的结构设计简洁却不简单，它像是一个精心设计的旅行箱，既有固定的格子放置物品，又能在需要时神奇地扩展容量。
让我们来看看它的内部构造：
typedef struct {
void *elts; /* 指向数组首元素的指针 */
ngx_uint_t nelts; /* 数组当前元素数量 */
size_t size; /* 单个元素的大小 */
ngx_uint_t nalloc; /* 数组的容量 */
ngx_pool_t *pool; /* 使用的内存池 */
} ngx_array_t;拿一个实际例子来说明，假设我们要创建一个存储整数的数组：
elts：指向实际存储整数内存块的指针nelts：当前数组中有多少个整数（类似于vector的size）size：sizeof(int)，通常是4字节nalloc：数组最多能存放多少个整数（类似于vector的capacity）pool：管理这块内存的内存池
与std::vector不同，ngx_array_t直接与内存池绑定，这使得它的内存分配策略与众不同。当数组需要扩容时，它不会直接调用malloc，而是向内存池申请更多空间。
这种设计的精妙之处在于：内存分配与释放的高效平衡。想象一下，传统的动态数组每次扩容都需要分配新内存、复制数据、释放旧内存，而ngx_array_t通过内存池技术，将这些操作大大简化。
03 动态数组的生命周期：从诞生到退役
创建数组：打好地基
创建Nginx动态数组就像预订一个餐厅包间，你需要提前告知预计多少人、每个人的空间需求：
// 创建一个初始容量为10，每个元素为int大小的数组
ngx_array_t *ngx_array_create(ngx_pool_t *pool, ngx_uint_t n, size_t size);实际使用示例：
// 在内存池中创建动态数组，初始容量为5，存储TestNode结构体
typedef struct {
int num;
char name[32];
} TestNode;
ngx_pool_t *pool = ngx_create_pool(1024, NULL);
ngx_array_t *dynamicArray = ngx_array_create(pool, 5, sizeof(TestNode));这个函数执行了两个关键操作：首先分配ngx_array_t结构体本身的内存，然后初始化数组成员。
初始化过程实际上是这样进行的：
static ngx_inline ngx_int_t
ngx_array_init(ngx_array_t *array, ngx_pool_t *pool, ngx_uint_t n, size_t size)
{
array->nelts = 0;
array->size = size;
array->nalloc = n;
array->pool = pool;
array->elts = ngx_palloc(pool, n * size);
if (array->elts == NULL) {
return NGX_ERROR;
}
return NGX_OK;
}添加元素：智能扩容的奥秘
向数组中添加元素是ngx_array_t最精彩的部分，它展现了Nginx设计者的智慧：
void *ngx_array_push(ngx_array_t *a);这个函数并不直接接受你要添加的数据，而是返回一块已经分配好的内存空间，让你自行填充数据。
这看似多了一步，实则是性能优化的关键。来看看实际使用的例子：
// 获取一个元素的空间并赋值
TestNode *a = ngx_array_push(dynamicArray);
a->num = 1;
strcpy(a->name, "first element");
// 再添加一个元素
a = ngx_array_push(dynamicArray);
a->num = 2;
strcpy(a->name, "second element");当数组已满时，ngx_array_push会触发扩容机制，这里的策略相当精明：
if (a->nelts == a->nalloc) { // 数组已满
size = a->size * a->nalloc;
p = a->pool;
if ((u_char *) a->elts + size == p->d.last &&
p->d.last + a->size <= p->d.end) {
// 情况1：内存池还有剩余空间，直接扩展
p->d.last += a->size;
a->nalloc++;
} else {
// 情况2：内存池空间不足，分配新数组
new = ngx_palloc(p, 2 * size);
ngx_memcpy(new, a->elts, size);
a->elts = new;
a->nalloc *= 2;
}
}Nginx的扩容策略比很多通用动态数组更聪明：它会先检查内存池当前块的剩余空间，如果足够就直接延展，不够时才分配新空间并复制数据。
这种策略就像是你在餐厅吃饭，刚开始给你安排了个8人桌，当需要加座时，如果旁边还有空间就直接加椅子，实在没空间了才换更大的包间。
批量添加与数组销毁
除了单个添加，Nginx还提供了批量添加函数：
void *ngx_array_push_n(ngx_array_t *a, ngx_uint_t n);这个函数让你能一次性添加多个元素，减少了重复扩容的开销。
当数组完成使命后，销毁工作也很简单：
void ngx_array_destroy(ngx_array_t *a);但要注意，销毁过程依赖于Nginx内存池的特性，它通过调整内存池的last指针来"释放"内存，这比真正的内存释放要高效得多。
04 实战演练：完整示例展示
理论说了这么多，让我们来看一个完整的示例，这个例子将展示Nginx动态数组的完整生命周期：
#include <ngx_config.h>
#include <ngx_core.h>
// 编译命令：根据实际Nginx源码路径调整
// gcc -I/path/to/nginx/src/core -I/path/to/nginx/src/os/unix -I/path/to/nginx/objs -o array_test array_test.c
typedef struct {
int id;
char name[64];
double price;
} Product;
int main() {
// 创建内存池
ngx_pool_t *pool = ngx_create_pool(1024, NULL);
if (pool == NULL) {
printf("创建内存池失败\n");
return 1;
}
// 创建动态数组，初始容量为3
ngx_array_t *products = ngx_array_create(pool, 3, sizeof(Product));
if (products == NULL) {
printf("创建动态数组失败\n");
return 1;
}
printf("数组创建成功：容量=%u, 元素大小=%zu\n",
products->nalloc, products->size);
// 添加产品1
Product *p1 = ngx_array_push(products);
p1->id = 1001;
ngx_snprintf(p1->name, sizeof(p1->name), "高性能服务器");
p1->price = 2999.99;
// 添加产品2
Product *p2 = ngx_array_push(products);
p2->id = 1002;
ngx_snprintf(p2->name, sizeof(p2->name), "负载均衡器");
p2->price = 1999.50;
printf("添加2个产品后，当前元素数量：%u\n", products->nelts);
// 批量添加3个产品
Product *batch_products = ngx_array_push_n(products, 3);
if (batch_products != NULL) {
int i;
for (i = 0; i < 3; i++) {
batch_products[i].id = 2000 + i;
ngx_snprintf(batch_products[i].name, sizeof(batch_products[i].name),
"批量产品%d", i + 1);
batch_products[i].price = 500.00 * (i + 1);
}
}
printf("批量添加后，当前元素数量：%u\n", products->nelts);
// 遍历并打印所有产品
Product *prods = products->elts;
ngx_uint_t i;
printf("\n所有产品信息：\n");
for (i = 0; i < products->nelts; i++) {
printf("产品%d: ID=%d, 名称=%s, 价格=%.2f\n",
i + 1, prods[i].id, prods[i].name, prods[i].price);
}
// 销毁数组和内存池
ngx_array_destroy(products);
ngx_destroy_pool(pool);
printf("\n动态数组使用示例完成\n");
return 0;
}这个示例展示了Nginx动态数组的典型使用场景：创建、添加元素、批量操作、遍历访问和清理。
实际运行这个程序，你会看到动态数组如何自动扩容，如何高效管理内存。
05 性能秘诀：Nginx动态数组的设计哲学
通过前面的分析，我们可以总结出ngx_array_t的几个关键设计哲学：
深度内存池集成
ngx_array_t与Nginx内存池深度绑定，这带来了显著性能优势。内存池通过批量分配和统一释放策略，极大减少了内存分配的系统调用次数。
谨慎的扩容策略
与std::vector简单的倍增策略不同，ngx_array_t的扩容更加精细和情境感知：
- 优先利用内存池当前块的剩余空间
- 空间不足时才分配新内存并复制数据
- 扩容时会检查是否是内存池的最后一块分配
零拷贝思维
ngx_array_push函数返回未初始化内存让用户填充，这种避免不必要拷贝的设计，体现了Nginx对性能的极致追求。
缓存友好布局
由于数据在内存中连续存储，ngx_array_t具有优秀的缓存局部性，这对于高性能服务器至关重要。
06 最佳实践与陷阱规避
在实际使用Nginx动态数组时，遵循以下实践可以让你的代码更高效可靠：
容量规划
虽然动态数组可以自动扩容，但合理的初始容量能避免多次扩容开销：
// 根据典型场景设置合适的初始容量
ngx_array_t *array = ngx_array_create(pool, estimated_size, sizeof(MyStruct));元素大小考量
尽量使用值类型或扁平结构体作为数组元素，避免复杂的嵌套指针结构，这样可以保证数据在内存中的连续性。
错误处理
始终检查数组操作函数的返回值：
MyStruct *element = ngx_array_push(array);
if (element == NULL) {
// 处理内存分配失败
return NGX_ERROR;
}
// 正常使用element及时清理
虽然内存池会自动管理内存，但显式销毁不再使用的数组是一个好习惯：
ngx_array_destroy(temp_array);07 超越动态数组：Nginx其他数据结构简介
Nginx的优秀不仅仅在于动态数组，它还实现了一系列高性能数据结构：
- ngx_list_t：存储数组的链表，每个节点是一个小数组，平衡了链表和数组的优点
- ngx_queue_t：侵入式双向链表，无需额外内存分配
- ngx_rbtree_t：红黑树实现，用于高效查找和排序
- ngx_hash_t：静态哈希表，一次构建多次查询
这些数据结构与ngx_array_t有着共同的设计理念：专注、高效、与内存池深度集成。
结语：小数据结构，大性能奥秘
Nginx的动态数组或许在功能上不如std::vector丰富，但它在自己专注的领域做到了极致。就像瑞士钟表，不以功能繁多取胜，而以精准可靠见长。
通过深度理解ngx_array_t的设计思想和实现细节，我们不仅能更好地使用Nginx，更能汲取宝贵的架构设计经验，将这些理念应用到自己的项目中。
下次当你面临高性能数据结构的选型时，不妨想想Nginx的动态数组——这个在简单中见真章的设计典范。
以上内容基于Nginx源码分析，实际使用时请参考对应版本的官方文档。Nginx的美丽不仅在于表面的高性能，更在于代码中蕴含的设计智慧。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
