Nginx学习笔记（五）：高级数据结构

目录

• 动态数组
• 单向链表
• 双端队列
• 红黑树
• 缓冲区
• 数据块链
• 键值对

 

动态数组

ngx_array_t 表示一块连续的内存，其中存放着数组元素，概念上和原始数组很接近

// 定义在 core/ngx_array.h
typedef struct
{
	void *			elts;		// 数组的内存位置，即数组首地址
	ngx_uint_t		nelts;		// 数组当前的元素数量
	size_t			size;		// 数组元素的大小
	ngx_uint_t		nalloc;		// 数组可容纳的最多元素容量
	ngx_pool_t * 	pool;		// 数组可使用的内存池
}ngx_array_t;

elts 就是原始的数组，定义成 void*，使用时应强转成相应的类型

nelts 相当于 vector.size();

size 相当于 sizeof(T);

nalloc 相当于 vector.capacity();

pool 数组使用的内存池，相当于 vector 的 allocator

数组里的元素不断增加，当 nelts > nalloc 时将引起数组扩容，ngx_array_t 会向内存池 pool 申请一块两倍原大小的空间————这个策略和 std::vector 是一样的

但 ngx_array_t 扩容成本太高，它需要重新分配内存并且将数据拷贝，所以最好一次性分配足够的空间，避免动态扩容

操作函数：

使用 ngx_array_t.elts 就可以访问数组里的元素，不过需要转换为实际元素类型

auto p = reinterpret_cast<T*>(arr.elts);
cout<<p[0]<<endl;

ngx_array_t 没有越界检查，需要自行确保数组索引的有效性

// 使用内存池 p 创建一个可容纳 n 个大小为 size 元素的数组，即分配了一块 n*size 大小的内存块
ngx_array_t * ngx_array_create(ngx_pool_t * p, ngx_uint_t n, size_t size);

// 销毁动态数组，归还分配的内存
void ngx_array_destory(ngx_array_t * a);

// 向数组添加元素，它们返回一个 void* 指针(可添加元素的位置)，需要转换类型才能再操作
// 不直接使用 elts 操作的原因是防止越界，函数内部会检查当前数组容量自动扩容
void * ngx_array_push(ngx_array_t * a);

void * ngx_array_push_n(ngx_array_t * a, ngx_uint_t n);

清空数组可以直接置 nelts 为 0, 但之前分配的内存并不会释放，还可以用来存储数据

---

单向链表

Nginx 的单向链表 ngx_list_t 融合了 ngx_array_t 的特点，在一个节点里存储多个元素，降低了链表的存储成本

// 定义在 core/ngx_list.h
struct ngx_list_part_s
{
	void * 				elts;		// 数组元素指针
	ngx_uint_t			nelts;		// 数组里的元素数量
	ngx_list_part_t *	next;		// 下个节点指针
};

ngx_list_t 定义了链表，实际上是 头结点 + 元信息：

// 定义在 core/ngx_list.h
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_array_t 数组结构

// 使用内存池创建链表，每个节点可容纳n个大小为size的元素
ngx_list_t * ngx_list_create(ngx_pool_t * pool, ngx_uint_t n, size_t size);

// 向链表里添加元素，返回的指针需要转型赋值
void * ngx_list_push(ngx_list_t * list);

eg.

part = &list.part;				// 获取头结点
data = part->elts;				// 获取节点内数组地址

for(i = 0; ; i++)				// 遍历链表
{
	if(i >= part->nelts)		// 检查数组越界
	{
		if(part->next == NULL)	// 检查是否到链表尾
		{
			break;
		}

		part = part->next;		// 跳至下一个节点
		data = part->data;		// 下一个节点的数组地址
		i = 0;
	}

	... data[i] ...				// 在本节点访问元素
}

---

双端队列

在Nginx 里它被实现为双向循环链表 ngx_queue_t，是侵入式容器

// 定义在 core/ngx_queue.h
struct ngx_queue_s
{
	ngx_queue_t * 	prev;		// 前驱指针
	ngx_queue_t * 	next;		// 后继指针
};

结构体需要添加它作为成员，为数据结构增加了双向链表的指针

struct X						// 一个可放入队列的数据结构
{
	int x = 0;					// 携带的数据
	ngx_queue_t queue;			// ngx_queue_t 成员，名字任意
};

结构体内可以有不止一个 ngx_queue_t 成员，这意味着它可以同时属于多个不同的双向链表

ngx_queue_t 使用一个头结点来表示队列，这个头节点可以是单纯的 ngx_queue_t 结构

// 函数宏 ngx_queue_init() 初始化头结点，把两个指针指向自身
#define ngx_queue_init(q)	\
	(q)->prev = q;			\
	(q)->next = q

// 函数宏 ngx_queue_sentinel() 返回节点自身，对于头结点就相当于哨兵
#define ngx_queue_sentinel(h) (h)

// ngx_queue_empty() 检查头结点的前驱指针，判断是否为空队列
#define ngx_queue_empty(h)	\
	(h == (h)->prev)

// 函数宏 ngx_queue_insert_head() 和 ngx_queue_insert_tail() 用来向头尾插入数据节点
#define ngx_queue_insert_head(h, x)
#define ngx_queue_insert_tail(h, x)

// 函数宏 ngx_queue_head() 和 ngx_queue_last() 获取队列的头尾指针
// 可以用来实现队列正向或反向遍历，直到遇到头结点 ngx_queue_sentinel()
#define ngx_queue_head(h) (h)->next
#define ngx_queue_last(h) (h)->prev

// 函数 ngx_queue_sort() 使用一个比较函数指针对队列元素排序，效率不是很高
void ngx_queue_sort(ngx_queue_t * queue,
	ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *));

数据节点操作

// 在节点的后面插入数据，它其实就是 ngx_queue_insert_head
#define ngx_queue_insert_after	ngx_queue_insert_head

// 删除节点，实际上只是调整了节点的指针，把节点从队列中摘除
#define ngx_queue_remove(x)		\
	(x)->next->prev = (x)->prev;\
	(x)->prev->next = (x)->next;

// 获取节点数据
#define ngx_queue_data(q, type, link)	\
	(type *)((u_char *) q - offsetof(type, link))	// 返回结构体指针（offsetof是一个宏，计算结构里成员的偏移量）

可以把双端队列分解为 节点、迭代器和队列容器三个概念：

节点保存数据，迭代器遍历数据，而队列容器则是头节点。

这三个概念可以使用C++封装成不同的类，达到解耦的目的

---

红黑树

在Nginx里红黑树主要用在事件机制里的定时器，检查连接超时，此外还在 reslover、cache里用于快速查找

// 定义在 core/ngx_rbtree.h
typedef ngx_uint_t		ngx_rbtree_key_t;
typedef ngx_int_t		ngx_rbtree_key_int_t;

struct ngx_rbtree_node_s
{
	ngx_rbtree_key_t		key;		// 红黑树的键，用于排序比较
	ngx_rbtree_node_t *		left;		// 左节点指针
	ngx_rbtree_node_t * 	right;		// 右结点指针
	ngx_rbtree_node_t * 	parent;		// 父节点指针
	u_char					color;		// 1 红色 / 0 黑色
	u_char					data;		// 节点数据，只有一字节，通常无意义
};

与 ngx_queue_t 一样，ngx_rbtree_node_t 也要作为结构体的一个成员，以侵入方式来使用

例如保存字符串的红黑树节点：

typedef struct
{
	ngx_rbtree_node_t	node;	// 红黑树节点，不必是第一个成员
	ngx_str_t			str;	// 节点的其他信息
} ngx_str_node_t;

// 节点的插入方法，函数指针类型
typedef void (*ngx_rbtree_insert_pt) (ngx_rbtree_node_t * root, ngx_rbtree_node_t, ngx_rbtree_sentinel);

struct ngx_rbtree_s
{
	ngx_rbtree_node_t * 	root;			// 红黑树的根节点
	ngx_rbtree_node_t *		sentinel;		// 哨兵节点，相当于空指针、空对象
	ngx_rbtree_insert_pt	insert;			// 节点的插入方法
};

insert决定了红黑树的节点插入操作，用户可以针对不同的节点类型实现不同的插入方法，但必须符合 ngx_rbtree_insert_pt 的定义

// 红黑树键值是标准的 uint/int
void ngx_rbtree_insert_value(root, node, sentinel);

// 定时器红黑树专用插入函数，键值是毫秒值
void ngx_rbtree_insert_timer_value(...);

// 字符串红黑树专用插入函数，键值是字符串的hash值
void ngx_str_rbtree_insert_value(...);

参考这三个函数可以实现自己的插入函数：

void ngx_rbtree_insert_value(...)		// 插入标准的红黑树，键值是整数
{
	ngx_rbtree_node_t ** p;				// 树节点指针
	for(;;)
	{									// 比较当前节点与插入节点，选择走左/右
		p = (node->key < temp->key) ? &temp->left : &temp->right;

		if(*p == sentinel)				// 直到遇到哨兵节点结束
			break;

		temp = *p;						// 移动当前指针
	}

	*p = node;							// 找到位置，插入
	node->parent = temp;
	node->left   = sentinel;
	node->right  = sentinel;
	ngx_rbt_red(node);
}

// 初始化宏，初始化后红黑树中仅有一个哨兵节点 s ，同时也是根节点
#define ngx_rbtree_init(tree, s, i)		// tree 使用 s 作为哨兵节点，插入方法是 i

// 红黑树的插入
void ngx_rbtree_insert(ngx_rbtree * tree, ngx_rbtree_node_t * node);
// 红黑树的删除
void ngx_rbtree_delete(ngx_rbtree * tree, ngx_rbtree_node_t * node);

• 操作后若树的平衡性被破坏会自动旋转以保持平衡

// 查找最小节点，顺着指针找最左边的节点
ngx_rbtree_node_t * ngx_rbtree_min()

ngx_rbtree_min() 只会返回 ngx_rbtree_node_t* 类型，若想得到完整的结构体指针，则需要利用宏 offsetof 计算偏移量再强制类型转换

// Nginx还提供查找下一个节点的功能，利用它可以实现正序遍历红黑树
ngx_rbtree_node_t * ngx_rbtree_next(ngx_rbtree_t * tree, ngx_rbtree_node_t * node);

// 对于常用的字符串红黑树，Nginx提供了专用的查找函数，它可以在树里找到任意字符串，不存在则返回 nullptr
ngx_str_node_t * ngx_str_rbtree_lookup(*rbtree, *name, hash);

---

缓冲区

作为web服务器，Nginx需要频繁收发处理大量的数据，这些数据有时是连续的内存块，有时是分散的内存块，甚至有时数据过大，内存无法存放，只能保存成磁盘文件

ngx_str_t 结构可以表示内存块，但不能应对复杂的情景，所以Nginx实现了 ngx_buf_t 和 ngx_chain_t

// ngx_buf_t 表示一个单块的缓冲区，既可以是内存也可以是文件
// 它的结构分为两个部分：缓冲区信息和标志位信息
typedef void *		ngx_buf_tag_t;

// 定义在 core/ngx_buf.h
struct ngx_buf_s
{
	u_char * 		pos;		// 内存数据的起始位置
	u_char * 		last;		// 内存数据的结束位置
	off_t			file_pos;	// 文件数据的起始偏移量
	off_t	 		file_last;	// 文件数据的结束偏移量

	u_char * 		start;		// 内存数据的上界
	u_char *		end;		// 内存数据的下界
	ngx_buf_tag_t	tag;		// void* 指针，可以是任意关联对象
	ngx_file_t *	file;		// 存储数据的文件对象

	...							// 标志位信息
};

因为Nginx的缓冲数据可能在内存或者磁盘文件中，所以 ngx_buf_t 使用 pos/last 和 file_pos/file_last 来指定数据在内存或文件中的具体位置，究竟数据在哪里则要靠后面的标志位信息来确定

start 和 end 两个成员变量标记了数据所在内存块的边界，如果内存块是可修改的，那么在操作时必须防止越界

tag 通常指向的是使用该缓冲区的对象

// ngx_buf_t 的标志位都是bool值，使用位域的方式节约内存

struct ngx_buf_s
{	...							// 缓冲区信息

	unsigned	temporary:1;	// 内存块临时数据，可以修改
	unsigned	memory:1;		// 内存块数据，不允许修改
	unsigned	mmap:1;			// 内存映射数据，不允许修改

	unsigned	in_file:1;		// 缓冲区在文件里
	unsigned	flush:1;		// 要求Nginx立即输出本缓冲区
	unsigned	sync:1;			// 要求Nginx同步操作本缓冲区
	unsigned	last_buf:1;		// 最后一块缓冲区
	unsigned	last_in_chain:1;// 链里最后一块缓冲区
	unsigned	temp_file:1;	// 缓冲区在临时文件里
};

其中 last_buf 表示整个处理过程的最后一块缓冲区，标志着 TCP/HTTP 请求处理的结束；

而 last_in_chain 表示当前数据块链（ngx_chain_t）里的最后一块，之后可能还有数据需要处理。

从 ngx_buf_t 的定义可以看到，一个有数据的缓冲区不是在内存里就是在文件里，所以内存标志位成员变量（temporary/memory/mmap）和文件标志成员变量（in_file/temp_file）不能全为0，否则Nginx 会认为这是个特殊（special）或无效的缓冲区。

如果缓冲区既不在内存也不在文件里，那么它就不含有有效数据，只起到控制作用，例如刷新（flush）或者同步（sync）

// 从内存池里分配一块 size 大小的缓冲区
ngx_buf_t * ngx_create_temp_buf(ngx_pool_t * pool, size_t size);

函数返回的 ngx_buf_t 结构内成员都已经初始化好了， pos 和 last 都指向内存块的首位置，表示空缓冲区，而temporary 标志位是1。

// 从内存池创建一个 ngx_buf_t 结构，然后手工指定它的成员，关联到已经存在的内存
#define ngx_alloc_buf(pool) 	ngx_palloc(pool, sizeof(ngx_buf_t))
#define ngx_calloc_buf(pool) 	ngx_pcalloc(pool, sizeof(ngx_buf_t)

// 检查缓冲区是否在内存里
#define ngx_buf_in_memory(b)		(b->temporary || b->memory || b->mmap)
#define ngx_buf_in_memory_only(b)	(ngx_buf_in_memory(b) && !b->in_file)

// 判断起控制作用的特殊缓冲区
#define ngx_buf_special(b)

// 计算缓冲区大小，根据是否在内存里使用恰当的指针
#define ngx_buf_size(b)

// 拷贝内存，返回拷贝数据后的终点位置，在连续复制多段数据时很方便
// 定义在 core/ngx_string.h
#define ngx_cpymem(dst, src, n)		(((u_char*)memcpy(dst, src, n)) + (n))

// 设置内存
#define ngx_memzero(buf, n)			(void) memset(buf, 0, n)
#define ngx_memset(buf, c, n)		(void) memset(buf, c, n)

---

数据块链

在处理HTTP/TCP请求时会经常创建多个缓冲区来存放数据，Nginx 把缓冲区块简单地组织为一个单向链表

ngx_chain_t 把多个分散的 ngx_buf_t 连接为一个顺序的数据块链：

// 定义在 core/ngx_buf.h
struct ngx_chain_s
{
	ngx_buf_t * 	buf;		// 缓冲区指针
	ngx_chain_t * 	next;		// 下一个链表节点
};

// 从内存池里获取 ngx_chain_t 对象
ngx_chain_t * ngx_alloc_chain_link(ngx_pool_t * pool);	// 内部调用 ngx_palloc()，获得的对象buf/next可能是任意值

// 释放 ngx_chain_t 对象
#define ngx_free_chain(pool, cl)

由于 ngx_chain_t 在 Nginx 里应用的很频繁，所以 Nginx 对此进行了优化。

在内存池里保存了一个空闲 ngx_chain_t 链表，分配时从这个链表中摘取，释放时再挂上去

typedef struct
{
	ngx_int_t	num;		// 缓冲区的数量
	size_t		size;		// 缓冲区的大小
} ngx_bufs_t;				// 创建链表的参数结构

// 创建多个缓冲区，返回一个链接好的数据块链表
ngx_chain_t  * ngx_create_chain_of_bufs(ngx_pool_t * pool, ngx_bufs_t * bufs);

仍然把 ngx_chain_t 分解为节点、迭代器和容器三个概念，不同C++类封装不同的操作

---

键值对

键值对是一种映射关系，C++使用std::pair 来表示，并且使用 std::map / std::unordered_map 存储这样的数据；

而 Nginx 提供两个结构：ngx_keyval_t 和 ngx_table_elt_t ，再结合 ngx_array_t 或 ngx_list_t 应用在不同的场合

ngx_keyval_t 是一个简单的键值对结构，主要用在 Nginx 的配置解析环节，保存配置文件里成对的配置。

// 定义在 core/ngx_string.h
typedef struct
{
	ngx_str_t 	key;
	ngx_str_t	value;
} ngx_keyval_t;

在 Nginx 里，通常使用 ngx_array_t 来存储 ngx_keyval_t，相当于

typedef NgxArray<ngx_keyval_t>		NgxKvArray;

散列表键值对

// 定义在 core/ngx_hash.h
typedef struct
{
	ngx_uint_t		hash;			// 散列（哈希）标记
	ngx_str_t		key;			// 键
	ngx_str_t		value;			// 值
	u_char * 		lowcase_key;	// key 的小写字符串指针
} ngx_table_elt_t;

ngx_table_elt_t 主要用来表示HTTP头部信息，例如

"Server:nginx" 这样的字符串对应到 ngx_table_elt_t 就是 key = "Server"，value = "nginx"

成员 hash 是一个散列标记，Nginx使用它在散列表中快速查找数据，

可以简单地把它置为非零值（通常为1），也可以使用下面两个函数计算散列值:

ngx_uint_t ngx_hash_key(u_char * data, size_t len);		// 计算散列值

ngx_uint_t ngx_hash_key_lc(u_char * data, size_t len);	// 小写后再计算

成员 lowcase_key 指向一个全小写的字符串，在大小写无关比较时可避免重复计算。

ngx_uint_t ngx_hash_strlow(u_char * dst, u_char * src, size_t n);	// 小写化同时计算散列值

Nginx 在处理HTTP请求时使用 ngx_list_t 存储了HTTP 头部信息，相当于：

typedef NgxList<ngx_table_elt_t>	NgxHeaderList;

---

 

C++封装实现：https://github.com/chen892704/Nginx-Learning