Nginx基础教程（17）Nginx高级数据结构之单向链表：深入Nginx的武器库：那把名为“单向链表”的内存刺客！

原创于 2025-11-27 12:28:57 发布 · 217 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #nginx #链表

Nginx基础教程专栏收录该内容

18 篇文章

订阅专栏

兄弟们，姐妹们，码农朋友们！今天咱们不聊Nginx如何叱咤风云，拳打Apache，脚踢Tomcat的光辉事迹。那些“百万并发”、“事件驱动”、“异步非阻塞”的大词儿，估计大家耳朵都听出茧子了。

今天，我们来点底层狠货，扒一扒Nginx华丽长袍下，那条朴实无华却至关重要的**“秋裤”——哦不，是单向链表**。

你可能会嗤之以鼻：“切，链表？我大学数据结构课闭着眼睛都能写出来！”

且慢！Nginx的单向链表，可不是你教科书里那个动不动就malloc、free，搞得内存碎片满天飞的“傻白甜”。它是经过Nginx核心团队千锤百炼，为高性能、高并发场景量身定制的 “内存管理刺客” 。它追求的不是花哨的功能，而是极致的速度与内存利用率。

第一章：为什么是它？Nginx的“抠门”哲学

在开始解剖之前，咱们得先理解Nginx的设计哲学。你可以把它想象成一个极致抠门的家庭主妇（绝无贬义！）。她对每一分钱（内存）、每一个动作（CPU周期）都精打细算。

在每秒要处理成千上万个请求的Web服务器里，频繁地向操作系统申请和释放内存，是性能的头号杀手。这会导致：

系统调用开销：malloc和free可不是免费的午餐。
内存碎片：反复申请释放不同大小的内存，会让可用的内存空间变得支离破碎，最后可能明明有足够的内存，却因为找不到一块连续的而申请失败。

Nginx的解决方案是：预分配 + 池化管理。它一次性申请一大块内存（内存池），然后自己在里面“分地”。而我们的主角——ngx_list_t（单向链表），就是管理这些“自留地”的优秀工具之一。它特别适合存储那些数量不确定、但每个元素大小固定的数据，比如HTTP头部的key: value对。

第二章：拆解“刺客”的武器：`ngx_list_t`结构探秘

来，直接上硬菜，看看Nginx源码中是怎么定义这个结构的（我们做了精简和注释，便于理解）：

/* 假设我们已经包含了必要的Nginx头文件 */
typedef struct ngx_list_part_s  ngx_list_part_t;

/* 链表的一部分，你可以把它想象成一节“火车车厢” */
struct ngx_list_part_s {
    void             *elts; /* 指向这节车厢里第一个座位的指针 */
    ngx_uint_t        nelts; /* 这节车厢已经坐了多少个乘客（元素） */
    ngx_list_part_t  *next; /* 指向下一节车厢的挂钩 */
};

/* 整个链表的“火车头”，管理着整列火车 */
typedef struct {
    ngx_list_part_t  *last;   /* 指向最后一节车厢（方便追加新车厢） */
    ngx_list_part_t   part;   /* 火车头自带的第一节车厢 */
    size_t            size;   /* 每个“乘客”（元素）的体型大小（字节） */
    ngx_uint_t        nalloc; /* 每一节车厢最多能装多少个乘客 */
    ngx_pool_t       *pool;   /* 这列火车运行在哪个“内存池”轨道上 */
} ngx_list_t;

怎么样，是不是比你想象的要复杂一丢丢？别慌，我们来打个绝妙的比方：

把ngx_list_t想象成一列绿皮火车：

ngx_list_t (整个结构体)：就是这列火车的总调度室（火车头）。它知道火车在哪条内存池轨道上跑，每节车厢坐多少人，乘客多大个头。
part (第一个节点)：是火车头后面自带的第一节车厢。这是一列实干型的火车，车头自己也拉客！
last (指针)：总调度室里有个对讲机，直接连着最后一节车厢。这样要加挂新车厢时，就不用从车头开始一节一节找了，直接找到最后一节挂上就行，效率极高！
size：规定了每个乘客（元素）的体型是固定的。比如都是“40字节”大小的乘客。你不能让一个200斤的胖子和一个80斤的瘦子坐在同一个定制的座位上。
nalloc：每一节车厢的定员。比如一节车厢能坐100个同样体型的乘客。
nelts：这节车厢当前已经坐了多少乘客。

它的工作流程是这样的：

初始化时，火车头（ngx_list_t）带着第一节空车厢（part）出厂。
你要添加乘客（数据），调度室就看最后一节车厢还有没有空座（nelts < nalloc）。
有空座？太好了！按照size大小，在车厢的elts指向的座位区，给新乘客安排一个座位，然后nelts加一。
最后一节车厢满员了？调度室通过对讲机last找到最后一节车厢，通过pool在内存池轨道上申请一块新的内存作为新车厢，用next挂钩连接上，然后更新last指针指向这节新车厢。
如此往复。

这样做最大的好处是什么？

批量操作，减少内存碎片！ 它不是来一个乘客就造一节车厢（每次分配一个元素），而是预分配一节能装nalloc个乘客的大车厢。这极大地减少了内存申请的次数，并且因为这些元素在内存中是连续存储的（在一节车厢内），遍历起来可以利用CPU缓存，速度飞快！

第三章：亲手打造你的Nginx式链表（完整示例）

理论说再多不如代码来得实在。下面，我们将在Linux环境下，用一个完整的C程序，模拟Nginx单向链表的核心操作。

这个示例包含了：

模仿ngx_list_t的结构定义。
创建链表（初始化）。
向链表添加元素。
遍历链表所有元素。
清理链表（由于我们简化了内存池，这里主要是释放所有part）。

注意：为了独立演示，我们使用了标准的malloc和free，而非Nginx内部的ngx_pool_t。在实际Nginx模块开发中，你应使用Nginx提供的内存池接口。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

/* 模仿 nginx_list_part_s：我们的“火车车厢” */
typedef struct list_part_s list_part_t;
struct list_part_s {
    void        *elts;      // 车厢座位区指针
    uint32_t     nelts;     // 当前乘客数
    list_part_t *next;      // 下一节车厢
};

/* 模仿 ngx_list_t：我们的“火车头” */
typedef struct {
    list_part_t *last;      // 最后一节车厢
    list_part_t  part;      // 第一节车厢（车头自带）
    size_t       size;      // 每个元素大小
    uint32_t     nalloc;    // 每节车厢容量
} list_t;

/* 创建链表（初始化火车头） */
list_t *list_create(size_t size, uint32_t nalloc) {
    // 申请火车头内存
    list_t *list = (list_t *)malloc(sizeof(list_t));
    if (list == NULL) {
        return NULL;
    }

    // 初始化火车头信息
    list->size = size;
    list->nalloc = nalloc;
    list->part.elts = NULL;
    list->part.nelts = 0;
    list->part.next = NULL;
    list->last = &list->part; // 刚开始，最后一节就是第一节

    // 为第一节车厢申请座位区内存
    list->part.elts = malloc(nalloc * size);
    if (list->part.elts == NULL) {
        free(list);
        return NULL;
    }

    return list;
}

/* 向链表添加一个元素（迎接新乘客） */
void *list_push(list_t *list) {
    list_part_t *last = list->last; // 找到最后一节车厢
    void        *elt;

    // 如果最后一节车厢满了，我们就需要挂接新车厢
    if (last->nelts >= list->nalloc) {
        // 造一节新车厢
        list_part_t *new_part = (list_part_t *)malloc(sizeof(list_part_t));
        if (new_part == NULL) {
            return NULL; // 造车厢失败
        }

        // 为新车厢分配座位区
        new_part->elts = malloc(list->nalloc * list->size);
        if (new_part->elts == NULL) {
            free(new_part);
            return NULL; // 分配座位失败
        }

        // 初始化新车厢
        new_part->nelts = 0;
        new_part->next = NULL;

        // 把新车厢挂到火车末尾
        last->next = new_part;
        list->last = new_part; // 更新总调度室的last指针
        last = new_part;       // 现在，last指向这节崭新的空车厢
    }

    // 现在last指向的车厢肯定有空座
    // 计算新乘客的座位地址
    elt = (char *)last->elts + (list->size * last->nelts);
    last->nelts++; // 乘客数+1

    return elt; // 返回这个座位的地址，让调用者放数据
}

/* 遍历链表并打印所有元素（假设我们存的是int） */
void list_traverse(const list_t *list) {
    const list_part_t *part = &list->part; // 从第一节车厢开始
    uint32_t i, j = 0; // j是总元素计数器

    printf("开始遍历链表...\n");
    while (part != NULL) {
        printf("  [车厢 %p, 已有元素: %u]\n", part, part->nelts);
        int *elts = (int *)(part->elts); // 强制转换为int指针

        for (i = 0; i < part->nelts; i++) {
            printf("    元素[%d] = %d\n", j, elts[i]);
            j++;
        }
        part = part->next; // 走向下一节车厢
    }
    printf("遍历结束，总计 %d 个元素。\n", j);
}

/* 销毁链表，释放所有内存（拆解整列火车） */
void list_destroy(list_t *list) {
    list_part_t *part = list->part.next; // 从第一节车厢之后开始拆

    // 先释放第一节车厢的座位区（车头自带的）
    free(list->part.elts);

    // 循环释放后面所有附加的车厢
    while (part != NULL) {
        list_part_t *next = part->next; // 先记住下一节在哪
        free(part->elts);  // 释放这节车厢的座位区
        free(part);        // 释放这节车厢本身
        part = next;       // 移动到下一节
    }

    // 最后释放火车头
    free(list);
}

/* 主函数：演示如何使用 */
int main() {
    // 创建一个链表，每个元素是int，每节“车厢”能容纳5个int
    list_t *my_list = list_create(sizeof(int), 5);
    if (my_list == NULL) {
        fprintf(stderr, "创建链表失败！\n");
        return 1;
    }

    printf("成功创建Nginx风格单向链表！\n");

    // 添加15个元素，这会产生 3 节车厢 (第一节5，第二节5，第三节5)
    printf("\n正在向链表添加15个元素（将自动扩容）...\n");
    for (int i = 0; i < 15; i++) {
        int *new_element = (int *)list_push(my_list);
        if (new_element == NULL) {
            fprintf(stderr, "添加元素 %d 失败！\n", i);
            list_destroy(my_list);
            return 1;
        }
        *new_element = i * 10; // 给新元素赋值
    }

    // 遍历并打印
    list_traverse(my_list);

    // 再添加3个，此时第三节车厢还有空位，不会扩容
    printf("\n再添加3个元素（不会触发扩容）...\n");
    for (int i = 15; i < 18; i++) {
        int *new_element = (int *)list_push(my_list);
        if (new_element == NULL) {
            fprintf(stderr, "添加元素 %d 失败！\n", i);
            list_destroy(my_list);
            return 1;
        }
        *new_element = i * 10;
    }

    // 再次遍历
    list_traverse(my_list);

    // 清理战场，销毁链表
    printf("\n正在销毁链表，释放内存...\n");
    list_destroy(my_list);
    printf("程序正常退出。\n");

    return 0;
}

编译和运行：

gcc -o nginx_list_demo nginx_list_demo.c
./nginx_list_demo

预期输出你会看到：
成功创建链表，添加15个元素后，链表自动扩容为3节车厢（每节5个元素）。随后再添加3个元素，因为最后一节车厢还有空位，所以没有扩容。最终打印出所有18个元素的值，并成功销毁释放内存。

第四章：它在Nginx体内到底干啥活？

说了这么多，这个“刺客”在Nginx的哪个战场上活动呢？

一个最经典的场景就是：解析HTTP请求头。

当Nginx收到一个HTTP请求时，它需要解析像Host: example.com、User-Agent: Chrome这样的头部字段。这些字段的数量是不确定的，但每个字段的key和value都可以用ngx_table_elt_t这个固定大小的结构体来表示。

这时，ngx_list_t就闪亮登场了！Nginx会使用一个预先初始化好的ngx_list_t来存储这些ngx_table_elt_t。

高效分配：利用内存池和预分配机制，快速地为每个头部字段分配内存，避免了频繁的系统调用。
连续存储：在单个part（车厢）内，头部字段是连续存储的，这对于缓存局部性非常友好，遍历查找时速度更快。
动态扩展：即使请求头非常多，链表也能通过增加part来轻松应对，保证了灵活性。

第五章：总结与升华

通过这次深度扒皮，我们发现，Nginx的强大并非仅仅源于那些高大上的架构，更源于这些对基础数据结构极致优化的细节。

ngx_list_t向我们展示了：

简单不代表弱小：在高手手中，最基础的单向链表也能玩出花。
场景决定设计：一切为了性能，为了内存。这种“抠门”是顶级软件的必要素养。
组合的威力：ngx_list_t通常与ngx_pool_t（内存池）协同工作，形成了Nginx坚固的内存管理基石。

下次当你配置Nginx，或者听说它又轻松扛住了多少流量时，不妨想起今天认识的这位幕后英雄——那条勤勤恳恳、高效节俭的 “单向链表” 。它或许没有“异步非阻塞”听起来酷炫，但正是这千千万万个精雕细琢的底层组件，共同托起了Nginx这座高性能的丰碑。

所以，别再小看链表了。它可能只是你简历上“熟练掌握数据结构”的一行字，但在Nginx的世界里，它是经过千锤百炼的内存刺客，是性能战场上不可或缺的无名英雄。