Nginx源码学习主要参考《深入理解Nginx模块开发与架构解析》陶辉著 据说是阿里的nginx技术专家。虔诚学习。。。。\T。T/
nginx的数据结构
nginx为了达到跨平台的目的，并且由于是由 C 开发，所以没有基本的容器来使用，所以对于nginx来说，为了满足以上两个要求，它的数据结构都是自我开发和封装的。
主要由以下几种数据结构：
- 双向链表 ngx_queue_t
- 红黑树 ngx_retree_t
- 动态数组 ngx_array_t
- 单向链表 ngx_list_t
- 基数树 ngx_radix_tree_t
- 散列哈希表 ngx_hash_t
双向链表 ngx_queue_t
链表作为顺序容器来说，它可以搞笑的完成执行、删除、合并等操作
ngx_queue_t的特点：
- 实现了排序功能
- 轻量级，数据结构中只有两个指针，一个前驱，一个后驱
- 支持两个链表间的合并
typedef struct ngx_queue_s ngx_queue_t;
struct ngx_queue_s{
ngx_queue_t *prev;
ngx_queue_t *next;
};
ngx_queue_t 这个数据类型实现了多种方法，而这些方法基本上是通过宏定义进行定义的，
ngx_queue_t容器提供的操作方法.png
我是第一次见到利用宏的形式来实现函数的方法，以前或许没有注意到，不过这次看起来这是对于数据结构来说不为是一种非常便捷的方法。
下面是测试案例和一些我加的注释(案例是来自上文提到的书中)
#include <stdio.h>
typedef struct ngx_queue_s ngx_queue_t;
struct ngx_queue_s{
ngx_queue_t *prev;
ngx_queue_t *next;
};//可以注意到其只有前驱后驱两个指针，也就是它们没有分配内存的功能。
typedef
struct my_queue{
char* str;
ngx_queue_t que;
int num;
}my_queue;//自定义数据结构，包含双链表数据结构
/*********双链表宏函数的实现********************/
#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 //h 是 初始的双链表头
#define ngx_queue_insert_after ngx_queue_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
#define ngx_queue_remove(x) \
(x) -> next -> prev = (x) -> prev; \
(x) -> prev -> next = (x) -> next
#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是链表容器，q是链表h的一个元素。\
//这个方法将链表h以元素q为界拆分成两个链表h和n，其中h有原链表的
//前半部分收成(不包括q),而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;
//offsetof这个宏可以用来表示一个数据结构里的成员对于这个数据结构来说
//的偏移量
#define offsetof(type,member) (size_t)&(((type*)0) -> member)
#define ngx_queue_data(q,type,link) \
(type *)((char*) q - offsetof(type,link))
/********************宏定义结束************************/
ngx_queue_t *ngx_queue_middle(ngx_queue_t *queue);
void ngx_queue_sort(ngx_queue_t *queue,
int (*cmp)(const ngx_queue_t*,
const ngx_queue_t *)){
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
if (q == ngx_queue_last(queue)){
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next){
prev = ngx_queue_prev(q);
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev);
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
int compTestNode(const ngx_queue_t* a,const ngx_queue_t* b){
/*首先使用ngx_queue_data方法由ngx_queue_t变量获取元素结构体
TestNode的地址*/
my_queue* aNode = ngx_queue_data(a,my_queue,que);
my_queue* bNode = ngx_queue_data(b,my_queue,que);
return aNode -> num > bNode -> num;
}
int main(int argc, char const *argv[])
{
ngx_queue_t queueContainer;
ngx_queue_init(&queueContainer);
int i = 0;
my_queue node[5];
for(;i < 5;++i){
node[i].num = i;
}
ngx_queue_insert_tail(&queueContainer,&node[0].que);
ngx_queue_insert_head(&queueContainer,&node[1].que);
ngx_queue_insert_tail(&queueContainer,&node[2].que);
ngx_queue_insert_after(&queueContainer,&node[3].que);
ngx_queue_insert_tail(&queueContainer,&node[4].que);
ngx_queue_sort(&queueContainer,compTestNode);
ngx_queue_t *q;
for(q = ngx_queue_head(&queueContainer);q != ngx_queue_sentinel(&queueContainer)
;q = ngx_queue_next(q)){
my_queue* eleNode = ngx_queue_data(q,my_queue,que);
printf("%d\n",eleNode -> num );
}
return 0;
}
其中有一个小技巧可以学习一下，就是计算一个数据结构相对于首地址的偏移量。
比如说
typedef
struct A{
int a;
int b;
int c;
}A；
/*
c相对于A来说偏移了8个单位，b相对于A来说偏移了4个单位。
*/
其实这可以通过offset这个宏来计算出来。
#define offsetof(type,member) (size_t)&(((type*)0) -> member)
将0地址强制转换成为type类型之后，将其成员的地址取出转换成为size_t也就是整形int，那么这个数就是该成员相对于这个数据类型的偏移量！
以上是对于nginx中出现的双向链表数据结构的总结，我感觉那几个宏还是挺有意思的，等有空把代码打印出来，好好看看。
