nginx源码初读(7)--让烦恼从数据结构开始(ngx_queue)

ngx_queue_t是nginx中的双向链表,我们看看它的数据结构,太简单:

typedef struct ngx_queue_s ngx_queue_t;
struct ngx_queue_s {
    ngx_queue_t  *prev;
    ngx_queue_t  *next;
};

是不是很简单?学过数据结构的我们一看就懂了。唉?等一下!等一下!等一下~~我老公呢~等一下。。(乱入,什么东西- -)

等一下,我们发现它少了我们必须用到的数据存储啊,我们链表里的数据放哪儿去了。刚开始我也很疑惑,后来看到它用得地方瞬间懂了,不只是懂了,瞬间惊呆了!!
它是这么用的:

ngx_queue_t free;            // 这是一个小哨兵,不存数据
ngx_queue_init(&free);       // 初始化一下下
struct node{
    int data;
    ngx_queue_t queue;       // 把queue这个结构体乖乖的放在我们要创建链表的结构里
}  node1;   
gx_queue_insert_head(&free, &node1.queue);
// 对!就这么用,先把queue放任意结构体里,再连到free这个哨兵上,都可以做链表用啦,写这个的人真是绝了

好了,知道它是怎么用的了,我们能放下好奇心好好看看代码了。

#define ngx_queue_init(q)                                                     \
    (q)->prev = q;                                                            \
    (q)->next = q
/* 初始化函数,哨兵的前后都是自己,也就是链表是空的,没有数据节点 */

#define ngx_queue_empty(h)    \
    (h == (h)->prev)
/* 判断链表是不是空的 */

#define ngx_queue_insert_head(h, x)                                           \
    (x)->next = (h)->next;                                                    \
    (x)->next->prev = x;                                                      \
    (x)->prev = h;                                                            \
    (h)->next = x
/* 插入是直接插入头部的 */ 

#define ngx_queue_insert_after   ngx_queue_insert_head
/* 插入到某节点的后面,跟insert_head是一样的 */

#define ngx_queue_insert_tail(h, x)                                           \
    (x)->prev = (h)->prev;                                                    \
    (x)->prev->next = x;                                                      \
    (x)->next = h;                                                            \
    (h)->prev = x
/* 因为是双向循环链表,头尾相连,所以插入到尾部也很容易,就是头部的前一个元素 */

#define ngx_queue_head(h)                                                     \
    (h)->next
#define ngx_queue_last(h)                                                     \
    (h)->prev
/* 通过哨兵获得头尾元素 */

#define ngx_queue_sentinel(h)                                                 \
    (h)
#define ngx_queue_next(q)                                                     \
    (q)->next
#define ngx_queue_prev(q)                                                     \
    (q)->prev
/* 返回自身或者前后的元素 */

#if (NGX_DEBUG)
#define ngx_queue_remove(x)                                                   \
    (x)->next->prev = (x)->prev;                                              \
    (x)->prev->next = (x)->next;                                              \
    (x)->prev = NULL;                                                         \
    (x)->next = NULL
#else
#define ngx_queue_remove(x)                                                   \
    (x)->next->prev = (x)->prev;                                              \
    (x)->prev->next = (x)->next
#endif
/* 把节点从链表中删除的操作,在debug模式下还会重置指针为null */

#define ngx_queue_split(h, q, n)                                              \
    (n)->prev = (h)->prev;                                                    \
    (n)->prev->next = n;                                                      \
    (n)->next = q;                                                            \
    (h)->prev = (q)->prev;                                                    \
    (h)->prev->next = h;                                                      \
    (q)->prev = n;
/* 注意一下!
 * 有人是这么说的:其中,h、n分别为两个队列的指针,即头节点指针,该操作将n队列链接在h队列之后。
 * 也有人表示完全看不懂~~
 * 我其实也是看不懂的,画了好久,同学们可以自己画一下,我感觉n是一个单独的节点, 
 * 然后把h远远连在前面(中间隔n个节点),把q连在后面(中间不隔节点),然后变成了一个环(大家画的时候要注意每个链表都是双向环形的)。
 * 好吧,不好意思我也没弄对,应该是这样:
 * 大家动手画一画吧,这个因为源码也没注释~~
 */

#define ngx_queue_add(h, n)                                                   \
    (h)->prev->next = (n)->next;                                              \
    (n)->next->prev = (h)->prev;                                              \
    (h)->prev = (n)->prev;                                                    \
    (h)->prev->next = h;
/* h、n分别为两个队列的指针,即头节点指针,该操作将n队列链接在h队列之后。*/

#define ngx_queue_data(q, type, link)                                         \
    (type *) ((u_char *) q - offsetof(type, link))
/* 依靠内存位置的off_t来得到相应节点元素数据的内存地址,q为当前地址,type为相应结构体的类型,link为queue */

另外两个非宏的函数:

/* 
 * find the middle queue element if the queue has odd number of elements 
 * or the first element of the queue’s second part otherwise 
 */  
ngx_queue_t *  
ngx_queue_middle(ngx_queue_t *queue)  
{  
    ngx_queue_t  *middle, *next;  
    middle = ngx_queue_head(queue);  
    if (middle == ngx_queue_last(queue)) {  
        return middle;  
    }  
    next = ngx_queue_head(queue);  
    for ( ;; ) {  
        middle = ngx_queue_next(middle);  
        next = ngx_queue_next(next);  
        // 偶数个节点,在此返回后半个队列的第一个节点  
        if (next == ngx_queue_last(queue)) {
            return middle;  
        }  
        //奇数个节点,在此返回中间节点
        next = ngx_queue_next(next);  
        if (next == ngx_queue_last(queue)) {  
            return middle;  
        }  
    }  
}  
/* 这个函数是用来获取列表最中间那个值的,使用了快慢指针的方法,mid移动1位,next就移动2位,返回mid */

void  
ngx_queue_sort(ngx_queue_t *queue,  
    ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *));
/* 使用了简单的插入排序算法,是一个稳定的排序 */
<think>嗯,用户现在问的是Nginx的高级数据结构,特别是ngx_queue_t的用途。之前用户已经询问过关于request_pool_size销毁的原因,可能现在想深入了解Nginx内部的实现机制。我需要先回忆一下ngx_queue_t的相关知识。 首先,ngx_queue_t是Nginx中一个双向链表的实现。用户可能想知道为什么Nginx要自己实现这样的数据结构,而不是使用C语言标准库里的结构。这可能涉及到性能优化、内存管理或者跨平台兼容性的问题。 接着,用户可能对具体的使用场景感兴趣。比如在HTTP模块中,Nginx如何处理请求,哪些部分会用到这种链表结构。需要举一些例子,比如维护定时事件、管理HTTP请求等,说明ngx_queue_t的实际应用。 另外,用户可能想了解这种数据结构的特点,比如轻量级、不侵入数据结构的实现方式。需要解释侵入式和非侵入式链表的区别,以及为什么Nginx选择这种方式。可能还要提到内存管理的优势,比如内存池的配合使用,减少内存碎片。 还要考虑用户可能的疑问,比如与其他数据结构如红黑树的区别。这时候需要指出链表和树的不同应用场景,比如链表适合频繁插入删除,而红黑树适合快速查找。说明Nginx如何根据不同的需求选择不同的数据结构。 另外,用户可能对如何在自己的模块中使用ngx_queue_t感兴趣,可能需要简单的代码示例,但用户问题中没有明确要求,所以可能不需要详细代码,但可以简要说明其使用方式,比如初始化、插入节点等步骤。 最后,总结ngx_queue_t的优势,比如高效、灵活、节省内存,以及为什么在Nginx中这样的设计是合理的,适合高并发场景的需求。同时确保回答结构清晰,符合之前用户要求的层次分明的格式,比如分点说明用途、设计特点、优势比较等。</think>Nginx 内部设计了许多高效的自定义数据结构以适配高并发场景,`ngx_queue_t` 是其中一种双向链表的实现,其核心价值在于**轻量级、无侵入、内存友好**的设计。以下是其关键用途与设计逻辑: --- ### 一、`ngx_queue_t` 的核心用途 1. **轻量级链表操作** - 用于需要频繁插入、删除但无需复杂查找的场景(如定时器事件管理、HTTP 请求阶段处理器链)。 - 示例: - 维护超时事件(`ngx_event_timer_rbtree` 结合红黑树和队列管理)。 - HTTP 请求处理阶段(`phase_engine` 中按顺序调用各阶段处理函数)。 2. **无侵入式设计** - 链表节点(`ngx_queue_t`)**不嵌入业务数据结构**,而是通过指针关联,避免强制耦合。 例如: ```c typedef struct { ngx_queue_t queue; // 链表节点 void *data; // 实际业务数据指针 } ngx_custom_node_t; ``` - 优势:同一业务结构可同时加入多个链表,灵活性高。 3. **内存池友好** - 节点内存通常从 Nginx 的 `ngx_pool_t` 内存池分配,生命周期与请求或连接绑定,避免内存泄漏。 --- ### 二、`ngx_queue_t` 的设计特点 1. **极简结构体** 仅包含前驱(`prev`)和后继(`next`)指针,无额外开销: ```c typedef struct ngx_queue_s ngx_queue_t; struct ngx_queue_s { ngx_queue_t *prev; ngx_queue_t *next; }; ``` 2. **高效操作宏** 提供宏直接操作链表,避免函数调用开销(如 `ngx_queue_insert_head`、`ngx_queue_remove`)。 3. **与红黑树互补** - **`ngx_queue_t`**:适合顺序遍历或频繁增删。 - **`ngx_rbtree_t`**:适合快速查找(如定时器、共享内存键值存储)。 - 两者常结合使用(例如定时器用红黑树管理超时时间,用队列维护活跃事件)。 --- ### 三、对比传统链表的优势 | 特性 | `ngx_queue_t` | 传统链表(如 Linux 内核 `list_head`) | |---------------------|--------------------------------|--------------------------------------| | **内存占用** | 更小(仅 2 指针) | 类似 | | **数据耦合** | 无侵入式 | 通常需嵌入结构体 | | **多链表支持** | 通过指针关联,灵活 | 需预先定义嵌入节点 | | **内存管理** | 深度整合 Nginx 内存池 | 依赖外部分配机制 | --- ### 四、典型应用场景 1. **HTTP 请求处理链** 各处理阶段(如 `NGX_HTTP_SERVER_REWRITE_PHASE`)通过链表串联处理函数。 2. **事件定时器** 超时事件按时间排序存入红黑树,活跃事件通过队列管理。 3. **模块配置合并** 多个模块的配置指令通过链表合并(如 `listen` 指令的 `ngx_listening_t` 列表)。 --- ### 五、使用示例(伪代码) ```c // 定义业务数据结构 typedef struct { int id; ngx_queue_t link; // 链表节点 } ngx_custom_data_t; // 初始化链表 ngx_queue_t head; ngx_queue_init(&head); // 插入节点 ngx_custom_data_t *node = ngx_palloc(pool, sizeof(ngx_custom_data_t)); node->id = 100; ngx_queue_insert_tail(&head, &node->link); // 遍历链表 ngx_queue_t *q; for (q = ngx_queue_head(&head); q != ngx_queue_sentinel(&head); q = ngx_queue_next(q)) { ngx_custom_data_t *data = ngx_queue_data(q, ngx_custom_data_t, link); // 处理 data->id } ``` --- ### 总结 `ngx_queue_t` 是 Nginx 为高并发场景量身定制的双向链表,其**无侵入、低开销、内存池集成**的特性,使其在事件管理、请求处理等核心流程中成为高效的基础设施。与红黑树等结构配合,共同支撑 Nginx 的高性能架构。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值