Nginx，永远滴神！

图片来自包图网

成都网站建设、成都做网站的关注点不是能为您做些什么网站，而是怎么做网站，有没有做好网站，给创新互联公司一个展示的机会来证明自己，这并不会花费您太多时间，或许会给您带来新的灵感和惊喜。面向用户友好，注重用户体验，一切以用户为中心。

Nginx 基础架构

Nginx 启动后以 daemon 形式在后台运行，后台进程包含一个 master 进程和多个 worker 进程。

如下图所示：

master 与 worker

Nginx 是由一个 master 管理进程，多个 worker 进程处理工作的多进程模型。

基础架构设计，如下图所示：

基础架构设计

master 负责管理 worker 进程，worker 进程负责处理网络事件。整个框架被设计为一种依赖事件驱动、异步、非阻塞的模式。

如此设计的优点：

  • 可以充分利用多核机器，增强并发处理能力。
  • 多 worker 间可以实现负载均衡。
  • Master 监控并统一管理 worker 行为。在 worker 异常后，可以主动拉起 worker 进程，从而提升了系统的可靠性。

并且由 Master 进程控制服务运行中的程序升级、配置项修改等操作，从而增强了整体的动态可扩展与热更的能力。

Master 进程

①核心逻辑

master 进程的主逻辑在 ngx_master_process_cycle，核心关注源码：

 
 
 
 
    
  
  
  
  
  1. ngx_master_process_cycle(ngx_cycle_t *cycle) 
    2.   
  
  
  
  2. { 
    3.   
  
  
  
  3.     ... 
    4.   
  
  
  
  4.     ngx_start_worker_processes(cycle, ccf->worker_processes, 
    5.   
  
  
  
  5.                                         NGX_PROCESS_RESPAWN); 
    6.   
  
  
  
  6.     ... 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     for ( ;; ) { 
    10.   
  
  
  
  10.         if (delay) {...} 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "sigsuspend"); 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         sigsuspend(&set); 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.         ngx_time_update(); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, 
    19.   
  
  
  
  19.                              "wake up, sigio %i", sigio); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.         if (ngx_reap) { 
    22.   
  
  
  
  22.             ngx_reap = 0; 
    23.   
  
  
  
  23.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "reap children"); 
    24.   
  
  
  
  24.             live = ngx_reap_children(cycle); 
    25.   
  
  
  
  25.         } 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.         if (!live && (ngx_terminate || ngx_quit)) {...} 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.         if (ngx_terminate) {...} 
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31.         if (ngx_quit) {...} 
    32.   
  
  
  
  32.  
    33.   
  
  
  
  33.         if (ngx_reconfigure) {...} 
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35.         if (ngx_restart) {...} 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.         if (ngx_reopen) {...} 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39.         if (ngx_change_binary) {...} 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41.         if (ngx_noaccept) { 
    42.   
  
  
  
  42.             ngx_noaccept = 0; 
    43.   
  
  
  
  43.             ngx_noaccepting = 1; 
    44.   
  
  
  
  44.             ngx_signal_worker_processes(cycle, 
    45.   
  
  
  
  45.                                                   ngx_signal_value(NGX_SHUTDOWN_SIGNAL)); 
    46.   
  
  
  
  46.         } 
    47.   
  
  
  
  47.     } 
    48.   
  
  
  
  48.  } 
    49.

由上述代码，可以理解，master 进程主要用来管理 worker 进程，具体包括如下 4 个主要功能：

  • 接受来自外界的信号。其中 master 循环中的各项标志位就对应着各种信号，如：ngx_quit 代表 QUIT 信号，表示优雅的关闭整个服务。
  • 向各个 worker 进程发送信。比如 ngx_noaccept 代表 WINCH 信号，表示所有子进程不再接受处理新的连接，由 master 向所有的子进程发送 QUIT 信号量。
  • 监控 worker 进程的运行状态。比如 ngx_reap 代表 CHILD 信号，表示有子进程意外结束，这时需要监控所有子进程的运行状态，主要由 ngx_reap_children 完成。
  • 当 woker 进程退出后(异常情况下)，会自动重新启动新的 woker 进程。主要也是在 ngx_reap_children。

②热更

热重载-配置热更：

热重载

  • Nginx 热更配置时，可以保持运行中平滑更新配置，具体流程如下：
  • 更新 nginx.conf 配置文件，向 master 发送 SIGHUP 信号或执行 nginx -s reload
  • master 进程使用新配置，启动新的 worker 进程

使用旧配置的 worker 进程，不再接受新的连接请求，并在完成已存在的连接后退出

热升级-程序热更：

热升级

Nginx 热升级过程如下：

  • 将旧 Nginx 文件换成新 Nginx 文件(注意备份)
  • 向 master 进程发送 USR2 信号(平滑升级到新版本的 Nginx 程序)
  • master 进程修改 pid 文件号，加后缀 .oldbin
  • master 进程用新 Nginx 文件启动新 master 进程，此时新老 master/worker 同时存在。
  • 向老 master 发送 WINCH 信号，关闭旧 worker 进程，观察新 worker 进程工作情况。

若升级成功，则向老 master 进程发送 QUIT 信号，关闭老 master 进程;若升级失败，则需要回滚，向老 master 发送 HUP 信号(重读配置文件)，向新 master 发送 QUIT 信号，关闭新 master 及 worker。

Worker 进程

①核心逻辑

worker 进程的主逻辑在 ngx_worker_process_cycle，核心关注源码：

 
 
 
 
    
  
  
  
  
  1. ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data) 
    2.   
  
  
  
  2. { 
    3.   
  
  
  
  3.     ngx_int_t worker = (intptr_t) data; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     ngx_process = NGX_PROCESS_WORKER; 
    6.   
  
  
  
  6.     ngx_worker = worker; 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8.     ngx_worker_process_init(cycle, worker); 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.     ngx_setproctitle("worker process"); 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     for ( ;; ) { 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.         if (ngx_exiting) {...} 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "worker cycle"); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.         ngx_process_events_and_timers(cycle); 
    19.   
  
  
  
  19.  
    20.   
  
  
  
  20.         if (ngx_terminate) {...} 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.         if (ngx_quit) {...} 
    23.   
  
  
  
  23.  
    24.   
  
  
  
  24.         if (ngx_reopen) {...} 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26. } 
    27.

由上述代码，可以理解，worker 进程主要在处理网络事件，通过 ngx_process_events_and_timers 方法实现，其中事件主要包括：网络事件、定时器事件。

②事件驱动-epoll

worker 进程在处理网络事件时，依靠 epoll 模型，来管理并发连接，实现了事件驱动、异步、非阻塞等特性。

如下图所示：

图

infographic-Inside-NGINX_nonblocking

通常海量并发连接过程中，每一时刻(相对较短的一段时间)，往往只需要处理一小部分有事件的连接即活跃连接。

基于以上现象，epoll 通过将连接管理与活跃连接管理进行分离，实现了高效、稳定的网络 IO 处理能力。

网络模型对比

其中，epoll 利用红黑树高效的增删查效率来管理连接，利用一个双向链表来维护活跃连接。

epoll 数据结构

③惊群

由于 worker 都是由 master 进程 fork 产生，所以 worker 都会监听相同端口。

这样多个子进程在 accept 建立连接时会发生争抢，带来著名的“惊群”问题。

worker 核心处理逻辑 ngx_process_events_and_timers 核心代码如下：

 
 
 
 
    
  
  
  
  
  1. void ngx_process_events_and_timers(ngx_cycle_t *cycle){ 
    2.   
  
  
  
  2.     //这里面会对监听socket处理 
    3.   
  
  
  
  3.     ... 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     if (ngx_accept_disabled > 0) { 
    6.   
  
  
  
  6.             ngx_accept_disabled--; 
    7.   
  
  
  
  7.     } else { 
    8.   
  
  
  
  8.         //获得锁则加入wait集合, 
    9.   
  
  
  
  9.         if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) { 
    10.   
  
  
  
  10.             return; 
    11.   
  
  
  
  11.         } 
    12.   
  
  
  
  12.         ... 
    13.   
  
  
  
  13.         //设置网络读写事件延迟处理标志，即在释放锁后处理 
    14.   
  
  
  
  14.         if (ngx_accept_mutex_held) { 
    15.   
  
  
  
  15.             flags |= NGX_POST_EVENTS; 
    16.   
  
  
  
  16.         } 
    17.   
  
  
  
  17.     } 
    18.   
  
  
  
  18.     ... 
    19.   
  
  
  
  19.     //这里面epollwait等待网络事件 
    20.   
  
  
  
  20.     //网络连接事件，放入ngx_posted_accept_events队列 
    21.   
  
  
  
  21.     //网络读写事件，放入ngx_posted_events队列 
    22.   
  
  
  
  22.     (void) ngx_process_events(cycle, timer, flags); 
    23.   
  
  
  
  23.     ... 
    24.   
  
  
  
  24.     //先处理网络连接事件，只有获取到锁，这里才会有连接事件 
    25.   
  
  
  
  25.     ngx_event_process_posted(cycle, &ngx_posted_accept_events); 
    26.   
  
  
  
  26.     //释放锁，让其他进程也能够拿到 
    27.   
  
  
  
  27.     if (ngx_accept_mutex_held) { 
    28.   
  
  
  
  28.         ngx_shmtx_unlock(&ngx_accept_mutex); 
    29.   
  
  
  
  29.     } 
    30.   
  
  
  
  30.     //处理网络读写事件 
    31.   
  
  
  
  31.     ngx_event_process_posted(cycle, &ngx_posted_events); 
    32.   
  
  
  
  32. } 
    33.

由上述代码可知，Nginx 解决惊群的方法：

  • 将连接事件与读写事件进行分离。连接事件存放为 ngx_posted_accept_events，读写事件存放为 ngx_posted_events。
  • 设置 ngx_accept_mutex 锁，只有获得锁的进程，才可以处理连接事件。

④负载均衡

worker 间的负载关键在于各自接入了多少连接，其中接入连接抢锁的前置条件是 ngx_accept_disabled > 0，所以 ngx_accept_disabled 就是负载均衡机制实现的关键阈值。

 
 
 
 
    
  
  
  
  
  1. ngx_int_t             ngx_accept_disabled; 
    2.   
  
  
  
  2. ngx_accept_disabled = ngx_cycle->connection_n / 8 - ngx_cycle->free_connection_n; 
    3.

因此，在 nginx 启动时，ngx_accept_disabled 的值就是一个负数，其值为连接总数的 7/8。

当该进程的连接数达到总连接数的 7/8 时，该进程就不会再处理新的连接了。

同时每次调用'ngx_process_events_and_timers'时，将 ngx_accept_disabled 减 1，直到其值低于阈值时，才试图重新处理新的连接。

因此，Nginx 各 worker 子进程间的负载均衡仅在某个 worker 进程处理的连接数达到它最大处理总数的 7/8 时才会触发，其负载均衡并不是在任意条件都满足。

如下图所示：

实际工作情况

其中'pid'为 1211 的进程为 master 进程，其余为 worker 进程。

思考

为什么不采用多线程模型管理连接?

①无状态服务，无需共享进程内存。

②采用独立的进程，可以让互相之间不会影响。一个进程异常崩溃，其他进程的服务不会中断，提升了架构的可靠性。

③进程之间不共享资源，不需要加锁，所以省掉了锁带来的开销。

为什么不采用多线程处理逻辑业务?

①进程数已经等于核心数，再新建线程处理任务，只会抢占现有进程，增加切换代价。

②作为接入层，基本上都是数据转发业务，网络 IO 任务的等待耗时部分，已经被处理为非阻塞/全异步/事件驱动模式，在没有更多 CPU 的情况下，再利用多线程处理，意义不大。

并且如果进程中有阻塞的处理逻辑，应该由各个业务进行解决，比如 OpenResty 中利用了 Lua 协程，对阻塞业务进行了优化。

作者：handsomeli，腾讯 IEG 后台开发工程师

编辑：陶家龙

出处：转载自公众号腾讯技术工程(ID：Tencent_TEG)

当前标题：Nginx，永远滴神！
文章链接：http://www.mswzjz.cn/qtweb/news41/37091.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

定制网站知识

同城分类信息

崇州做网站　　 　led发光广告字　　 　成都营销网站建设　　 　网站改版　　 　成都网络营销　　 　江油做网站　　 　成都名片印刷　　 　成都手机网站报价　　 　成都主机托管　　 　公司宣传册设计　　 　网络营销推广　　 　电商网站　　 　成都服务器租赁　　 　品牌网站建设公司　　 　整合营销　　 　SF双层罐　　 　达州电信机房　　 　重庆APP开发　　 　宣威网站建设　　 　成都网站设计