Nginx学习笔记(四):基本数据结构 - 陈心朔

技术分享 Story 86浏览 0评论

目录
  • Nginx的一些特点
  • Nginx自定义整数类型
  • 异常机制错误处理
  • 内存池
  • 字符串
  • 时间与日期
  • 运行日志

 

Nginx的一些特点

  • 高性能
    采用事件驱动模型,可以无阻塞的处理海量并发连接

  • 高稳定性
    内存池避免了 c 程序常见的资源泄漏问题
    模块化架构使得各个功能模块完全解耦
    one master / mutil workers 进程池设计实现了自我监控管理,保证一个 worker 挂掉也能快速恢复服务

  • 低资源消耗
    不使用传统的进程或线程服务器模型,没有切换成本
    使用很多节约系统资源的编程技巧

  • 高扩展性
    模块化架构,可以根据需要开发适合自己业务逻辑的模块


Nginx自定义整数类型

跨平台兼容

// 定义在 core/ngx_config.h
typedef intptr_t 	ngx_int_t;		// 有符号整数
typedef uintptr_t	ngx_uint_t;		// 无符号整数
typedef intptr_t	ngx_flag_t;		// 标志整数类型
  • intptr_t、uintptr_t 是C/C++标准里 大小足够容纳指针的整数类型
// 定义在 core/ngx_rbtree.h 红黑树的键(key)类型
typedef ngx_uint_t	ngx_rbtree_key_t;
typedef ngx_int_t	ngx_rbtree_key_int_t;

// 定义在 os/unix/ngx_time.h 毫秒的整数类型
typedef ngx_rbtree_key_t	ngx_msec_t;
typedef ngx_rbtree_key_int_t	ngx_msec_int_t;

无效值:
在Nginx中,定义了类似python的None,初始化变量以 UNSET = -1 表示未初始化
由于C/C++是强类型语言,Nginx为 -1 定义了不同类型转换的宏

// 定义在 core/ngx_conf_file.h
#define NGX_CONF_UNSET							-1	// 通用无效值
#define NGX_CONF_UNSET_UINT		(ngx_uint_t)	-1	// 无符号整数的无效值
#define NGX_CONF_UNSET_PTR		(void *)		-1	// 指针类型的无效值
...

有了UNSET概念,Nginx 以宏的形式提供了初始化和条件赋值函数:

// 定义在 core/ngx_conf_file.h
#define ngx_conf_init_value(conf, default)		\
	if(conf == NGX_CONF_UNSET)					\
	{											\
		conf = default;							\
	}

当conf未初始化,初始化为default默认值


异常机制错误处理

分离代码逻辑里的正常部分和异常部分,使代码的结构更加清晰

Nginx用宏定义了七个常用的错误码,类型是 ngx_int_t

// 定义在 core/ngx_core.h
#define NGX_OK			0 	// 执行成功,无错误
#define NGX_ERROR	   -1	// 执行失败,最常见的错误
#define NGX_AGAIN	   -2	// 未准备好,需要重试
#define NGX_BUSY	   -3	// 后端服务正忙
#define NGX_DONE	   -4	// 执行成功,但还需要有后序操作
#define NGX_DECLINED   -5	// 执行成功,但未做处理
#define NGX_ABORT	   -6	// 发生了严重的错误

内存池

减少了系统调用的次数,而且能够很好的避免内存碎片和泄漏

// 定义在 ngx_core.h
typedef struct ngx_pool_s	ngx_pool_t;		// 简化定义

// 定义在 ngx_palloc.h
struct ngx_pool_s
{
	...
	ngx_pool_cleanup_t	*cleanup;			// 析构时的清理动作
	ngx_log_t			*log;				// 关联的日志对象
}

Nginx 会为每一个 TCP/HTTP 请求创建一个独立的内存池————也就是 ngx_pool_t 对象
当请求结束时自动销毁 ngx_pool_t 对象,释放内存池和它拥有的所有内存

// 使用了内存对齐,速度快,但可能会有少量内存浪费
void * ngx_palloc(ngx_pool_t  * pool, size_t size);
// 没有使用内存对齐
void * ngx_pnalloc(ngx_pool_t * pool, size_t size);
// 内部调用了 ngx_palloc(),并且把内存块清零
void * ngx_pcalloc(ngx_pool_t * pool, size_t size);
// 释放内存
ngx_int_t ngx_free(ngx_pool_t * pool, void * p);

清理机制:
Nginx框架自动管理内存池的生命周期,当请求结束时内存池里的内存会完全归还给系统;
内存只是系统资源的一个方面,其他的系统资源(如文件句柄)并不会随着内存池的销毁而一并释放;
如果不做特殊的操作就可能造成资源泄漏。

这种清理机制就是C++里的析构函数思想,在对象销毁的时候自动调用析构函数

Nginx 定义了一个保存清理信息的结构 ngx_pool_cleanup_t,用来在内存销毁时执行清理动作

// 定义在 ngx_palloc.h
typedef void (*ngx_pool_cleanup_t) void * data;		// 清理函数指针原型

struct ngx_pool_cleanup_s							// 清理信息结构体
{
	ngx_pool_cleanup_pt		handler;				// 清理动作,函数指针
	void 				   	*data;					// 清理所需数据
	ngx_pool_cleanup_t		*next;					// 后续链表指针
};

// 定义在 ngx_palloc.h
ngx_pool_cleanup_pt * ngx_pool_cleanup_add(ngx_pool_t * p, size_t size);

这个函数使用 size 为 ngx_pool_cleanup_t::data 分配内存,返回清理信息 ngx_pool_cleanup_t 对象,
设置它的 handler 和 data,就可以达到向内存池"注册"清理函数的目的

std::vector 有两个模板参数:

template<class T,								// 容纳的元素类型 
		class Alloctor = std::allocator<T>		// 内存配置器
		> class vector

我们可以自定义内存配置器替换第二个参数,vector就能使用Nginx的内存池


字符串

ngx_str_t 不是传统意义上的字符串,准确的说应该是一个 内存块引用

// 定义在 ngx_string.h
typedef struct
{
	size_t 		len;	// 字符串长度
	u_char * 	data;	// 字符串所在地址
}ngx_str_t;

这种设计的好处是字符串的操作非常廉价,只有两个整数的成本,
不需要复制大量数据,所以对它的拷贝、修改都非常高效,也节约了内存的使用
(类似 boost::string_ref 或者 std::string_view C++17 )

缺点也显而易见,由于 ngx_str_t 只是引用内存,所以应该尽量以只读方式去使用
多个 ngx_str_t 共享一块内存,擅自修改内容会影响到其他的引用
同时引用的内存地址可能失效,访问到错误的内存区域

初始化与赋值:

#define ngx_string(str)		{sizeof(str) - 1, (u_char *) str}
#define ngx_null_string		{0, NULL}

#define ngx_str_set(str, text)	\
...
#define ngx_str_null(str)		\
...

基本操作:

#define ngx_strcmp(s1, s2)		// 大小写敏感比较,参数是 u_char*
#define ngx_strncmp(s1, s2, n)	// 大小写敏感比较,有长度参数

#define ngx_strstr(s1, s2)		// 查找子串
#define ngx_strlen(s)			// 使用\'\0\'计算字符串长度

// 大小写不敏感字符串比较,参数是 u_char*
ngx_int_t ngx_strcasecmp(u_char * s1, u_char * s2);
ngx_int_t ngx_strncasecmp(u_char * s1, u_char * s2, size_t n);

// 字符串转整数类型,参数是 u_char*
ngx_int_t ngx_atoi(u_char * line, size_t n);

// 内存池复制字符串,参数是 ngx_str_t*
u_char * ngx_pstrdup(ngx_pool_t * pool, ngx_str_t * src);

格式化函数:

// 直接向 buf 输出格式化内容,不检查缓冲区的有效性
u_char * ngx_sprintf(u_char * buf, const char * fmt, ...);
// 参数 max 和 last 指明了缓冲区结束位置
u_char * ngx_snprintf(u_char * buf, size_t max, const char * fmt, ...);
u_char * ngx_slprintf(u_char * buf, u_char * last, const char * fmt, ...);

函数执行完返回 u_char* 指针,指示格式化输出后在 buf 里的结束位置,可以用来判断结果的长度


时间与日期

Nginx定义了专用的时间数据结构 ngx_time_t:

// 定义在 core/ngx_times.h
typedef struct
{
	time_t		sec;		// 自 epoch 以来的秒数,即时间戳
	ngx_uint_t	msec;		// 秒数后的小数部分,单位是毫秒
	ngx_int_t	gmtoff;		// GMT时区偏移量
} ngx_time_t;

Nginx 内部使用了cache机制来存放时间值,使用一个全局指针 ngx_cached_time 指示当前缓存的时间

volatile ngx_time_t * ngx_cached_time;		// 当前缓存的时间

// 获取当前时间的秒数
#define ngx_time()		ngx_cached_time->sec
// 获取完整的时间结构体
#define timeofday()		(ngx_time_t *)ngx_cached_time

// 强制更新缓存时间(需要使用锁,成本较高,当必须获得当前精确时间时调用)
void ngx_time_update(void)

日期结构,是标准C结构< ctime>里的tm

// 定义在 os/unix/ngx_time.h
typedef struct tm 	ngx_tm_t;

日期操作函数

// 定义在 core/ngx_times.h
void ngx_gmtime()time_t t, ngx_tm_t * tp);
void ngx_localtime(time_t t, ngx_tm_t * tp);

将 time_t 转换为格林尼治时间/本地时间

u_char * ngx_http_time(u_char * buf, time_t t);
u_char * ngx_http_cookie_time(u_char * buf, time_t t);

上面两个函数调用了 ngx_gmtime() 和 ngx_sprintf(), 把 time_t 转换成日期字符串

// 定义在 core/ngx_parse_time.h
time_t ngx_parse_http_time(u_char * value, size_t len);

解析字符串形式的日期时间,转换为 time_t

同时,Nginx 使用全局变量提供缓存好的日期字符串,减少频繁调用的成本:

ngx_str_t ngx_cached_err_log_time;		// 错误日志的日期字符串
ngx_str_t ngx_cached_http_time;			// HTTP格式的日期字符串
ngx_str_t ngx_cached_http_log_time;		// HTTP日志的日期字符串
ngx_str_t ngx_cached_http_log_iso8601;	// ISO8601 格式日期字符串
ngx_str_t ngx_cached_syslog_time;		// 系统日志格式日期字符串

运行日志

Nginx 使用结构体 ngx_log_t 表示运行日志

// 定义在 core/ngx_log.h
struct ngx_log_s
{
	...
	ngx_uint_t 		log_level;		// 日志级别
	ngx_log_t * 	next;			// 日志对象链表指针
};

// 定义在 core/ngx_log.h
void ngx_log_error_core(ngx_uint_t level, ngx_log_t * log, ngx_err_t err,
						const char * fmt, ...);

使用 ngx_log_t 对象记录 level 级别的日志,字符串消息的格式语法与 ngx_sprintf() 相同

日志级别参数 level 取决于下列的宏,他们对应配置文件里的
debug | info | notice | warn | error | crit | alert | emerg

#define NGX_LOG_STDERR		0	// 最高级别
#define NGX_LOG_EMERG		1
#define NGX_LOG_ALERT		2
#define NGX_LOG_CRIT		3
#define NGX_LOG_ERR			4	// 常用级别
#define NGX_LOG_WARN		5
#define NGX_LOG_NOTICE		6
#define NGX_LOG_INFO		7
#define NGX_LOG_DEBUG		8	// 最低级别

STDERR 是比 emerg 还要高的错误级别,如果使用这个级别来记录日志,
那么 Nginx 将直接输出日志到标准错误输出(通常为终端屏幕)而非写入日志文件。

常用的日志级别为 NGX_LOG_ERR 和 NGX_LOG_WARN

err 参数表示调用失败返回的错误码

// 定义在 os/unix/errno.h
typedef int 	ngx_err_t;

日志宏

#define ngx_log_error(level, log, ...)		\
...

只有当消息的日志级别高于log对象级别(即消息的level值小)时才会调用函数记录日志

  • 实际开发中应该使用宏来记录日志 *

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

转载请注明:成长的对话 » Nginx学习笔记(四):基本数据结构 - 陈心朔