Nginx源码学习之路----熟悉Nginx基本的数据结构

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 

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中出现的双向链表数据结构的总结，我感觉那几个宏还是挺有意思的，等有空把代码打印出来，好好看看。