说明：上一节Gdb 调Nginx，这一节我们深入代码本身，以下是我个人对Nginx代码的初步理解，若有出错，不吝赐教。
Nginx两大进程
- 核心进程:包括监控进程和工作进程
- Cache进程:Cache管理进程和Cache加载进程
Nginx核心进程模型
Ngnix的进程模型将进程分成监控进程和工作进程两类，启动Nginx的主进程将充当监控进程，而由主进程fork()出来的子进程则充当工作进程。工作进程的任务自然是完成具体的业务逻辑，而监控进程充当整个进程组与用户的交互接口，同时对进程进行监护。
分析Nginx多线程模型入口为主进程ngx_master_process_cycle()函数，在该函数完成信号处理设置等之后就会调用一个名为ngx_start_worker_process()用于fork()产生出子进程，子进程作为一个新的实体开始充当工作进程的角色执行ngx_worker_process_cycle()函数，该函数主体作为一个无限for(;;)循环，持续不断处理客户端的服务请求；而主进程继续执行ngx_master_process_cycle()函数，也就是作为监控进程执行主体for(;;)循环，指导进程退出。
监控进程
监控进程的无限for(;;)内有一个关键的sigsuspend()函数调用，该函数使得控制进程大部分时间都处于挂起等待状态，直到监控进程接收到信号为止。信号处理函数一般都要要求足够简单。实际的处理逻辑必须放在主体代码里面运行。
代码例子:：文件名为:ngx_process_cycle.c
void
ngx_master_process_cycle(ngx_cycle_t *cycle)
{
for ( ;; ) {
if (delay) {
if (ngx_sigalrm) {
sigio = 0;
delay *= 2;
ngx_sigalrm = 0;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"termination cycle: %M", delay);
itv.it_interval.tv_sec = 0;
itv.it_interval.tv_usec = 0;
itv.it_value.tv_sec = delay / 1000;
itv.it_value.tv_usec = (delay % 1000 ) * 1000;
if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"setitimer() failed");
}
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "sigsuspend");
sigsuspend(&set); // 继续等待新的信号
ngx_time_update();
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"wake up, sigio %i", sigio);
if (ngx_reap) {
ngx_reap = 0;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children");
live = ngx_reap_children(cycle);
}
if (!live && (ngx_terminate || ngx_quit)) {
ngx_master_process_exit(cycle);
}
if (ngx_terminate) {
if (delay == 0) {
delay = 50;
}
if (sigio) {
sigio--;
continue;
}
sigio = ccf->worker_processes + 2 /* cache processes */;
......
}
工作进程
工作进程的执行主体与监控进程类似，不过关注点是客户端或是真实服务器之间数据可读/可写等I/O交互事件，而不是进程信号。所以工作进程的阻塞点主要是select(),epoll_wait()等这样的I/O多路复用函数调用处。
代码在ngx_process_cycle.c
static void
ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
{
ngx_int_t worker = (intptr_t) data;
ngx_process = NGX_PROCESS_WORKER;
ngx_worker = worker;
ngx_worker_process_init(cycle, worker);
ngx_setproctitle("worker process");
for ( ;; ) {
if (ngx_exiting) {
ngx_event_cancel_timers();
if (ngx_event_timer_rbtree.root == ngx_event_timer_rbtree.sentinel)
{
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
ngx_worker_process_exit(cycle);
}
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle");
ngx_process_events_and_timers(cycle); // 调用到对应的时间监控阻塞点，ngx_process_events_and_timers()->ngx_process_events()/ngx_epoll_process_events()->epoll_wait()
if (ngx_terminate) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
ngx_worker_process_exit(cycle);
}
if (ngx_quit) {
ngx_quit = 0;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
"gracefully shutting down");
ngx_setproctitle("worker process is shutting down");
if (!ngx_exiting) {
ngx_exiting = 1;
ngx_close_listening_sockets(cycle);
ngx_close_idle_connections(cycle);
}
}
if (ngx_reopen) {
ngx_reopen = 0;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
ngx_reopen_files(cycle, -1);
}
}
}Cache进程模型
如果Nginx开启了缓存功能，比如proxy cache，那么Nginx将还创建另外两个Cache相关进程。编写类似下列Nginx配置文件
http {
include mime.types;
default_type application/octet-stream;
#log_format main '$remote_addr - $remote_user [$time_local] "$request" '
# '$status $body_bytes_sent "$http_referer" '
# '"$http_user_agent" "$http_x_forwarded_for"';
#access_log logs/access.log main;
sendfile on;
#tcp_nopush on;
#keepalive_timeout 0;
keepalive_timeout 65;
#gzip on;
proxy_cache_path /data/nginx/cache/one levels=1:2 keys_zone=one:10m;
server {
listen 80;
server_name localhost;
#charset koi8-r;
#access_log logs/host.access.log main;
location / {
proxy_cache one;
proxy_cache_valid 200 302 10m;
root html;
index index.html index.htm;
}
}
Cache 进程处理客户端请求，也没有没监控I/O事件，而其处理的是超时事件在ngx_process_events_and_timers()函数内执行的事件处理函数ngx_event_expire_timers()
Cache 管理进程
Cache管理进程与Cache加载进程的主流进程都是ngx_cache_manager_process_cycle()函数，但它们附带的函数参数是不同的，管理进程执行到函数ngx_cache_manger_process_cycle()内时传递的数据是ngx_cache_manger_ctx。
在文件:ngx_process_cycle.c
static void
ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data)
{
ngx_cache_manager_ctx_t *ctx = data; //cache 两种进程不同功能，就是data的值不一样
void *ident[4];
ngx_event_t ev;
/*
* Set correct process type since closing listening Unix domain socket
* in a master process also removes the Unix domain socket file.
*/
ngx_process = NGX_PROCESS_HELPER;
ngx_close_listening_sockets(cycle); // cache不监听，所以关闭监听套接字。
/* Set a moderate number of connections for a helper process. */
cycle->connection_n = 512;
ngx_worker_process_init(cycle, -1);
ngx_memzero(&ev, sizeof(ngx_event_t));
ev.handler = ctx->handler;
ev.data = ident;
ev.log = cycle->log;
ident[3] = (void *) -1; //仅只是因为事件对象的data字段一般挂载的是connet对象，此处设置为-1刚好是把connect对象的fd字段设置为-1，以避免在其他代码里走到异常逻辑。
ngx_use_accept_mutex = 0;
ngx_setproctitle(ctx->name);
ngx_add_timer(&ev, ctx->delay);//ctx->delay 为0，因此超时，执行对应的函数ngx_process_events_timers() -> ngx_event_expire_timers() -> ngx_cache_manager_process_handler()
for ( ;; ) {
if (ngx_terminate || ngx_quit) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
exit(0);
}
if (ngx_reopen) {
ngx_reopen = 0;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
ngx_reopen_files(cycle, -1);
}
ngx_process_events_and_timers(cycle);
}
}
Cache管理进程不接收客户端请求，关闭了监听套接口，其他带代码完成创建一事件对象并设置了对应的超时事件。
static void
ngx_cache_manager_process_handler(ngx_event_t *ev)
{
time_t next, n;
ngx_uint_t i;
ngx_path_t **path;
next = 60 * 60;
path = ngx_cycle->paths.elts;
for (i = 0; i < ngx_cycle->paths.nelts; i++) {
if (path[i]->manager) {
n = path[i]->manager(path[i]->data);
next = (n <= next) ? n : next;
ngx_time_update();
}
}
if (next == 0) {
next = 1;
}
ngx_add_timer(ev, next * 1000);
}
函数ngx_cache_mangager_process_handler()的处理很简单，调用每一个磁盘缓存管理对象的manger()函数，然后重新设置事件对象的下一次超时立刻返回。这里的manager函数这是Nginx在调用函数ngx_http_file_cache_set_slot()解析配置文件指令proxy_cache_path时设置的回调值。
加入这边设置的manager函数对应的回调值为ngx_http_file_cache_manager
这个函数的实现在:ngx_http_file_cache.c
static time_t
ngx_http_file_cache_manager(void *data)
{
ngx_http_file_cache_t *cache = data;
off_t size;
time_t next, wait;
ngx_uint_t count, watermark;
next = ngx_http_file_cache_expire(cache);
cache->last = ngx_current_msec;
cache->files = 0;
for ( ;; ) {
ngx_shmtx_lock(&cache->shpool->mutex);
size = cache->sh->size;
count = cache->sh->count;
watermark = cache->sh->watermark;
ngx_shmtx_unlock(&cache->shpool->mutex);
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
"http file cache size: %O c:%ui w:%i",
size, count, (ngx_int_t) watermark);
if (size < cache->max_size && count < watermark) {
return next;
}
wait = ngx_http_file_cache_forced_expire(cache);
if (wait > 0) {
return wait;
}
if (ngx_quit || ngx_terminate) {
return next;
}
}
}
主要实现了删除过期的缓存文件然后检查缓存文件总大小是否超限，如果超限则强行删除。总而言之，cache管理进程的任务就是清理超时缓存文件，限制缓存文件的总大小
Cache加载进程
在一段时间后Cache加载进程将消失，这是因为Cache加载进程的功能就是在Nginx正常启动后，将磁盘上次缓存的对象读入内存中，这个过程是一次性，所以完成这个动作之后就退出。
Cache加载进程执行到ngx_cache_manager_process_cycle()为止的上层函数调用与cache管理进程一致，但是在该函数内设置的事件对象回调函数为ngx_cache_loader_process_handler()
static void
ngx_cache_loader_process_handler(ngx_event_t *ev)
{
ngx_uint_t i;
ngx_path_t **path;
ngx_cycle_t *cycle;
cycle = (ngx_cycle_t *) ngx_cycle;
path = cycle->paths.elts;
for (i = 0; i < cycle->paths.nelts; i++) {
if (ngx_terminate || ngx_quit) {
break;
}
if (path[i]->loader) {
path[i]->loader(path[i]->data);
ngx_time_update();
}
}
exit(0);
}
注意该函数的最后一行的exit(0),可见Cache加载进程的执行逻辑是一次性的。假设我们这边对应的loader()函数被设置为ngx_http_file_cache_loader()函数，该函数给磁盘缓存管理对象对应路径下已有的缓存文件建立对应的红黑树。
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
