| 信号 | 对应进程中的全局标志位变量 | 意义 |
| QUIT | ngx_quit | 优雅地关闭整个服务 |
| TERM或INT | ngx_terminate | 强制关闭整个服务 |
| USR1 | ngx_reopen | 重新打开服务中的所有文件 |
| WINCH | ngx_noaccept | 所有子进程不再接受处理新的连接，实际相当于对所有子进程发送QUIT信号 |
| USR2 | ngx_change_binary | 平滑升级到新版本的Nginx程序 |
| HUP | ng_reconfigure | 重读配置文件 |
| CHLD | ngx_reap | 有子进程以外结束，需要监控所有子进程 |
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigaddset(&set, SIGALRM);
sigaddset(&set, SIGIO);
sigaddset(&set, SIGINT);
sigaddset(&set, ngx_signal_value(NGX_RECONFIGURE_SIGNAL));
sigaddset(&set, ngx_signal_value(NGX_REOPEN_SIGNAL));
sigaddset(&set, ngx_signal_value(NGX_NOACCEPT_SIGNAL));
sigaddset(&set, ngx_signal_value(NGX_TERMINATE_SIGNAL));
sigaddset(&set, ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
sigaddset(&set, ngx_signal_value(NGX_CHANGEBIN_SIGNAL));
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"sigprocmask() failed");
} ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
ngx_start_worker_processes(cycle, ccf->worker_processes,
NGX_PROCESS_RESPAWN);
ngx_start_cache_manager_processes(cycle, 0); for (i = 0; i < n; i++) {
cpu_affinity = ngx_get_cpu_affinity(i);
ngx_spawn_process(cycle, ngx_worker_process_cycle, NULL,
"worker process", type);
ch.pid = ngx_processes[ngx_process_slot].pid;
ch.slot = ngx_process_slot;
ch.fd = ngx_processes[ngx_process_slot].channel[0];
ngx_pass_open_channel(cycle, &ch);
} if (ngx_quit) {
ngx_signal_worker_processes(cycle,
ngx_signal_value(NGX_SHUTDOWN_SIGNAL));
ls = cycle->listening.elts;
for (n = 0; n < cycle->listening.nelts; n++) {
if (ngx_close_socket(ls[n].fd) == -1) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,
ngx_close_socket_n " %V failed",
&ls[n].addr_text);
}
}
cycle->listening.nelts = 0;
continue;
}这段位于master cycle中的代码是对SIGQUIT信号进行的处理动作。ngx_quit就那个全局变量之一，当master进程收到这个信号的时候，就调用ngx_signal_handler(定义在src/os/unix/ngx_process.c文件中)设置ngx_quit为1。因此master从sigsuspend返回后，检测到ngx_quit为1，就调用ngx_signal_worker_processes函数向每个worker进程递送SIGQUIT信号，通知worker进程们开始退出工作。然后就关闭所有的监听套接字。最后居然来了一个continue就又回到了cycle中，不是退出吗？为什么是continue而不是exit呢。前面已经提过了，master进程是幕后者，需要守护着worker进程们，既然是守护哪能worker进程没撤退，自己就先撤退了呢。由于，worker进程是master的子进程，所以worker退出后，将发送SIGCHLD信号给master进程，好让master进程为其善后（否则将出现“僵尸”进程）。在master进程收到SIGCHLD信号，就会设置全局变量ngx_reap为1了。
if (ngx_reap) {
ngx_reap = 0;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children");
live = ngx_reap_children(cycle);
} ngx_process = NGX_PROCESS_WORKER;
if (ngx_set_environment(cycle, NULL) == NULL) {
/* fatal */
exit(2);
} for (i = 0; ngx_modules[i]; i++) {
if (ngx_modules[i]->init_process) {
if (ngx_modules[i]->init_process(cycle) == NGX_ERROR) {
/* fatal */
exit(2);
}
}
}
/*
此处循环用于关闭其他worker进程的无用channel资源
*/
for (n = 0; n < ngx_last_process; n++) {
/*
ngx_processes数组中n位置的进程不存在。
*/
if (ngx_processes[n].pid == -1) {
continue;
}
/*
全局变量ngx_process_slot的值是创建worker进程的时候，从
master进程复制过来的，所以此处ngx_process_slot就指本worker
进程在ngx_process_slot数组中的索引位置。此处不处理本worker
进程，所以跳过。
*/
if (n == ngx_process_slot) {
continue;
}
/*
channel不存在，继续跳过。
*/
if (ngx_processes[n].channel[1] == -1) {
continue;
}
/*
ngx_processes数组中存储的是每个worker进程的资源，是master进程负责创建的。
因此创建一个worker进程的时候，就一同将这些资源复制过来了，所以此处就关闭
无用的channel——其他worker进程的读端文件描述符，保留写端文件描述符做
worker间的通信之用。
*/
if (close(ngx_processes[n].channel[1]) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"close() channel failed");
}
}
/*
关闭本worker进程channel的写端文件描述符，因为每个worker进程只从自己的channel
上读，而不会写。写自己channel的是master和其他worker进程。这也是上面为什么要
关闭其他worker进程channel的读端。
*/
if (close(ngx_processes[ngx_process_slot].channel[0]) == -1) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"close() channel failed");
} if (ngx_add_channel_event(cycle, ngx_channel, NGX_READ_EVENT,
ngx_channel_handler)
== NGX_ERROR)
{
/* fatal */
exit(2);
} for ( ;; ) {
/*
ngx_exiting是在worker进程收到SIGQUIT信号后设置的，稍后就能看到庐山真面目了。
*/
if (ngx_exiting) {
c = cycle->connections;
/*
worker进程退出前，先得处理完每个connection上已经发生的事件。
*/
for (i = 0; i < cycle->connection_n; i++) {
/* THREAD: lock */
if (c[i].fd != -1 && c[i].idle) {
c[i].close = 1;
c[i].read->handler(c[i].read);
}
}
/*
处理完所有事件后，调用ngx_worker_process_exit函数，worker进程退出。
*/
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");
/*
这里是worker进程处理事件的核心开始。也即是，worker进程从里开始做一些特定的事情了，
我们完全可以修改此处的代码，让Nginx为我们做一些其他的事情，呵呵。
*/
ngx_process_events_and_timers(cycle);
/*
worker进程收到了SIGINT信号，退出。
*/
if (ngx_terminate) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
ngx_worker_process_exit(cycle);
}
/*
worker进程收到了SIGQUIT信号，如果此时worker进程不是出于exiting状态，
就将设置ngx_exiting为1，让其进入exiting状态；同时关闭监听套接口。
*/
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_close_listening_sockets(cycle);
ngx_exiting = 1;
}
}
/*
worker进程收到了SIGUSR1信号
*/
if (ngx_reopen) {
ngx_reopen = 0;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
ngx_reopen_files(cycle, -1);
}
}这部分实现的源码主要分布于src/os/unix/channel.h和channel.c两个文件中。实现极其简单，没有什么复杂的逻辑。下面，我绘制了一个简单的master进程和worker进程间的关系，图中的箭头符号指出数据是由master进程传给worker进程，而没有从worker到master；这是因为channel不是一个普通的数据传输管道，在Nginx中它仅仅是用着master发送指令给worker的一个管道，master借此channel来告诉worker进程该做什么了，worker却不需要告诉master该做什么，所以是一个单向的通道。
master进程每次发送给worker进程的指令用如下一个结构来完成封装：
typedef struct {
ngx_uint_t command;
ngx_pid_t pid;
ngx_int_t slot;
ngx_fd_t fd;
} ngx_channel_t;这个结构中的4个字段分别是发送的指令、worker进程的pid、worker进程的slot（在ngx_proecsses中的索引）及一个文件描述符。master进程可能会将一个打开的文件描述符发送给worker进程进行读写操作，那么此时就需要填写fd这个字段了。worker进程在收到一个这样的结构数据后，通过判断command的值来采取相应的动作；command就是master给worker下达的命令。
master进程用于处理SIGCHLD信号的函数ngx_reap_children中就有向worker进程发送关闭channel的指令，我们看看这个例子是怎么做的。
ch.command = NGX_CMD_CLOSE_CHANNEL;
ch.fd = -1;
ch.pid = ngx_processes[i].pid;
ch.slot = i;
ngx_write_channel(ngx_processes[n].channel[0],
&ch, sizeof(ngx_channel_t), cycle->log);这几行代码是我从ngx_reap_children函数中拼凑起来的，所以看上去好像有点奇怪，不那么顺畅；但却清晰的给我们展现了master进程怎么给一个worker进程发送指令，此处发送的指令时NGX_CMD_CLOSE_CHANNEL。发送指令的函数ngx_write_channel是利用sendmsg来完成，《Unix网络编程》可以详细了解sendmsg。
worker进程在调用ngx_worker_process_init进行初始化的时候，使用了如下两行代码将channel放到epoll等事件处理模块中。
if (ngx_add_channel_event(cycle, ngx_channel, NGX_READ_EVENT,
ngx_channel_handler)
== NGX_ERROR)
{
/* fatal */
exit(2);
} /*
读出master进程发送给过来的指令数据, ngx_read_channel
是利用recvmsg实现，详细介绍见《unix网络编程》
*/
n = ngx_read_channel(c->fd, &ch, sizeof(ngx_channel_t), ev->log);
/*
判断command的值，从而采取具体的动作，代码意图都写得很明显，
就不在这里多说了。
*/
switch (ch.command) {
case NGX_CMD_QUIT:
ngx_quit = 1;
break;
case NGX_CMD_TERMINATE:
ngx_terminate = 1;
break;
case NGX_CMD_REOPEN:
ngx_reopen = 1;
break;
case NGX_CMD_OPEN_CHANNEL:
ngx_processes[ch.slot].pid = ch.pid;
ngx_processes[ch.slot].channel[0] = ch.fd;
break;
case NGX_CMD_CLOSE_CHANNEL:
if (close(ngx_processes[ch.slot].channel[0]) == -1) {
ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
"close() channel failed");
}
ngx_processes[ch.slot].channel[0] = -1;
break;
}