_小青年儿_
_小青年儿_

NGX负载均衡策略

负载均衡策略


nginx的负载均衡策略可以划分为两大类：内置策略和扩展策略。内置策略包含加权轮询和ip hash，在默认情况下这两种策略会编译进nginx内核，只需在nginx配置中指明参数即可。扩展策略有很多，如fair、通用hash、consistent hash等，默认不编译进nginx内核，是第三方模块。

nginx 的 upstream目前支持 4 种方式的分配 ：

1)轮询（默认） 

      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 

2)weight 

      指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。 

2)ip_hash 

      每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。  

3)fair（第三方） 

      按后端服务器的响应时间来分配请求，响应时间短的优先分配。  

4)url_hash（第三方）


Nginx默认采用round_robin加权算法。如果要选择其他的负载均衡算法，必须在upstream的配置上下文中通过配置指令ip_hash明确指定（该配置项最好放在其他server指令等的前面，以便检查server的配置选项是否合理）。比如采用Ip_hash的upstream配置如下所示：

[cpp]  view plain copy print ?
  1. upstream load_balance{  
  2.     ip_hash;  
  3.     server localhost:8001;  
  4.     server localhost:8002;  
  5. }  

Load-blance模块中4个关键回调函数：
表1

回调指针

函数功能

round_robin模块

IP_hash模块

uscf->peer.init_upstream

解析配置文件过程中调用，根据upstream里各个server配置项做初始准备工作，另外的核心工作是设置回调指针us->peer.init。配置文件解析完后不再被调用

ngx_http_upstream_init_round_robin

设置：us->peer.init = ngx_http_upstream_init_round_robin_peer;

ngx_http_upstream_init_ip_hash

设置：us->peer.init = ngx_http_upstream_init_ip_hash_peer;

us->peer.init

在每一次Nginx准备转发客户端请求到后端服务器前都会调用该函数。该函数为本次转发选择合适的后端服务器做初始准备工作，另外的核心工作是设置回调指针r->upstream->peer.get和r->upstream->peer.free等

ngx_http_upstream_init_round_robin_peer

设置：r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;

r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;

ngx_http_upstream_init_ip_hash_peer

设置：r->upstream->peer.get = ngx_http_upstream_get_ip_hash_peer;

r->upstream->peer.free为空

r->upstream->peer.get

在每一次Nginx准备转发客户端请求到后端服务器前都会调用该函数。该函数实现具体的位本次转发选择合适的后端服务器的算法逻辑，即完成选择获取合适后端服务器的功能

ngx_http_upstream_get_round_robin_peer

加权选择当前权值最高的后端服务器

ngx_http_upstream_get_ip_hash_peer

根据IP哈希值选择后端服务器

r->upstream->peer.free

在每一次Nginx完成与后端服务器之间的交互后都会调用该函数。

ngx_http_upstream_free_round_robin_peer

更新相关数值，比如rrp->current


当整个http配置块被Nginx解析完毕之后，会调用各个http模块对应的初始函数。对于模块ngx_http_upstream_module而言，对应的main配置初始函数是ngx_http_upstream_init_main_conf()，在这个函数中有这样一段代码：
[cpp]  view plain copy print ?
  1. for (i = 0; i < umcf->upstreams.nelts; i++) {  
  2.   
  3.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:  
  4.                                             ngx_http_upstream_init_round_robin;  
  5.   
  6.         if (init(cf, uscfp[i]) != NGX_OK) {  
  7.             return NGX_CONF_ERROR;  
  8.         }  
  9. }  
默认采用加权轮询策略的原因就是在于上述代码中的init赋值一行。如果用户没有做任何策略选择，那么执行的策略初始函数为ngx_http_upstream_init_round_robin，也就是加权轮询策略。否则的话执行的是uscfp[i]->peer.init_upstream指针函数，如果有配置执行ip_hash ，那么就是ngx_http_upstream_init_ip_hash()。

加权轮询策略

全局准备工作


需要注意的是，配置文件中出现的参数只能和某些策略配合使用，所以如果发现某参数没有生效，则应该检查这一点。在配置解析的过程中，这些选项设置都被转换为Nginx内对于的变量值，对应的结构体ngx_http_upstream_server_t如下（ngx_http_upstream.h）：
[cpp]  view plain copy print ?
  1. typedef struct {  
  2.     ngx_addr_t                      *addrs;//指向存储IP地址的数组的指针，host信息(对应的是 ngx_url_t->addrs )  
  3.     ngx_uint_t                       naddrs;//与第一个参数配合使用，数组元素个数(对应的是 ngx_url_t->naddrs )  
  4.     ngx_uint_t                       weight;  
  5.     ngx_uint_t                       max_fails;  
  6.     time_t                           fail_timeout;  
  7.   
  8.     unsigned                         down:1;  
  9.     unsigned                         backup:1;  
  10. } ngx_http_upstream_server_t;  
这个阶段的函数是ngx_http_upstream_init_round_robin()，其主要完成的工作详见表1.

首先是设置了一个回调指针，这个函数用来针对每个请求选择后端服务器之前做一些初始化工作：
[cpp]  view plain copy print ?
  1. us->peer.init = ngx_http_upstream_init_round_robin_peer;  

us类型是ngx_http_upstream_srv_conf_t：
[cpp]  view plain copy print ?
  1. typedef struct ngx_http_upstream_srv_conf_s  ngx_http_upstream_srv_conf_t;  
  2.   
  3. struct ngx_http_upstream_srv_conf_s {  
  4.     ngx_http_upstream_peer_t         peer;  
  5.     void                           **srv_conf;//在 ngx_http_upstream()函数中被设置，指向的是本层的srv_conf  
  6.   
  7.     ngx_array_t                     *servers;  /*array of ngx_http_upstream_server_t */  
  8.   
  9.     ngx_uint_t                       flags;//调用函数时ngx_http_upstream_add() 指定的标记  
  10.     ngx_str_t                        host;//在函数 ngx_http_upstream_add() 中设置（e.g. upstream backend中的backend）  
  11.     u_char                          *file_name;//"/usr/local/nginx/conf/nginx.conf"  
  12.     ngx_uint_t                       line;//proxy在配置文件中的行号  
  13.     in_port_t                        port;//使用的端口号（ngx_http_upstream_add()函数中添加, 指向ngx_url_t-->port，通常在函数ngx_parse_inet_url()中解析）  
  14.     in_port_t                        default_port;//默认使用的端口号（ngx_http_upstream_add()函数中添加, 指向ngx_url_t-->default_port）  
  15.     ngx_uint_t                       no_port;  /* unsigned no_port:1 */  
  16. };  

而ngx_http_upstream_peer_t ：
[cpp]  view plain copy print ?
  1. typedef struct {  
  2.     //使用负载均衡的类型，默认采用 ngx_http_upstream_init_round_robin（）  
  3.     ngx_http_upstream_init_pt        init_upstream;  
  4.     //使用的负载均衡类型的初始化函数  
  5.     ngx_http_upstream_init_peer_pt   init;  
  6.     //us->peer.data = peers; 指向的是 ngx_http_upstream_rr_peers_t（函数 ngx_http_upstream_init_round_robin()中设置）  
  7.     void                            *data;  
  8. } ngx_http_upstream_peer_t;  

ngx_http_upstream_init_peer_pt  是函数指针类型：
[cpp]  view plain copy print ?
  1. typedef ngx_int_t (*ngx_http_upstream_init_peer_pt)(ngx_http_request_t *r,  
  2.     ngx_http_upstream_srv_conf_t *us);  
服务器类型ngx_http_upstream_server_t见前面的解释。

如果upstream中服务器为空，那么默认使用proxy_pass。将利用函数ngx_inet_resolve_host依据us参数中的host和port进行解析。将结果保存在一个ngx_url_t类型的变量中：
[cpp]  view plain copy print ?
  1. typedef struct {  
  2.     ngx_str_t                 url;                  //保存IP地址+端口信息（e.g. 192.168.124.129:8011 或 money.163.com）  
  3.     ngx_str_t                 host;                 //保存IP地址信息  
  4.     ngx_str_t                 port_text;                //保存port字符串  
  5.     ngx_str_t                 uri;                  //uri部分，在函数ngx_parse_inet_url()中设置  
  6.   
  7.     in_port_t                 port;                 //端口，e.g. listen指令中指定的端口（listen 192.168.124.129:8011）  
  8.     in_port_t                 default_port;             //默认端口（当no_port字段为真时，将默认端口赋值给port字段， 默认端口通常是80）  
  9.     int                       family;                   //address family, AF_xxx  
  10.   
  11.     unsigned                  listen:1;             //是否为指监听类的设置  
  12.     unsigned                  uri_part:1;  
  13.     unsigned                  no_resolve:1;             //根据情况决定是否解析域名（将域名解析到IP地址）  
  14.     unsigned                  one_addr:1;               //等于1时，仅有一个IP地址  
  15.   
  16.     unsigned                  no_port:1;                //标识url中没有显示指定端口(为1时没有指定)  
  17.     unsigned                  wildcard:1;               //标识是否使用通配符（e.g. listen *:8000;）  
  18.   
  19.     socklen_t                 socklen;              //sizeof(struct sockaddr_in)  
  20.     u_char                    sockaddr[NGX_SOCKADDRLEN];        //sockaddr_in结构指向它  
  21.   
  22.     ngx_addr_t               *addrs;                //数组大小是naddrs字段；每个元素对应域名的IP地址信息(struct sockaddr_in)，在函数中赋值（ngx_inet_resolve_host()）  
  23.     ngx_uint_t                naddrs;               //url对应的IP地址个数,IP格式的地址将默认为1  
  24.   
  25.     char                     *err;                  //错误信息字符串  
  26. } ngx_url_t;  

此函数会创建后端服务器列表，并且将非后备服务器与后备服务器分开进行各自单独的链表。每一个后端服务器用一个结构体ngx_http_upstream_rr_peer_t与之对应（ngx_http_upstream_round_robin.h）：
[cpp]  view plain copy print ?
  1. typedef struct {  
  2.     struct sockaddr                *sockaddr;//后端服务器地址  
  3.     socklen_t                       socklen;//后端服务器地址长度  
  4.     ngx_str_t                       name;//后端名称  
  5.   
  6.     ngx_int_t                       current_weight;//当前权重，nginx会在运行过程中调整此权重  
  7.     ngx_int_t                       effective_weight;  
  8.     ngx_int_t                       weight;//配置的权重  
  9.   
  10.     ngx_uint_t                      fails;//已尝试失败次数  
  11.     time_t                          accessed;//检测失败时间，用于计算超时  
  12.     time_t                          checked;  
  13.   
  14.     ngx_uint_t                      max_fails;//最大失败次数  
  15.     time_t                          fail_timeout;//多长时间内出现max_fails次失败便认为后端down掉了  
  16.   
  17.     ngx_uint_t                      down;          /* unsigned  down:1; *///指定某后端是否挂了  
  18.   
  19. #if (NGX_HTTP_SSL)  
  20.     ngx_ssl_session_t              *ssl_session;   /* local to a process */  
  21. #endif  
  22. } ngx_http_upstream_rr_peer_t;  

列表最前面需要带有一些head信息，用结构体ngx_http_upstream_rr_peers_t与之对应：
[cpp]  view plain copy print ?
  1. typedef struct ngx_http_upstream_rr_peers_s  ngx_http_upstream_rr_peers_t;  
  2.   
  3. struct ngx_http_upstream_rr_peers_s {  
  4.     ngx_uint_t                      number;//队列中服务器数量  
  5.   
  6.  /* ngx_mutex_t                    *mutex; */  
  7.   
  8.     ngx_uint_t                      total_weight;//所有服务器总权重  
  9.   
  10.     unsigned                        single:1;//为1表示后端服务器总共只有一台，用于优化，此时不需要再做选择  
  11.     unsigned                        weighted:1;//为1表示总的权重值等于服务器数量  
  12.   
  13.     ngx_str_t                      *name;  
  14.   
  15.     ngx_http_upstream_rr_peers_t   *next;//后备服务器列表挂载在这个字段下  
  16.   
  17.     ngx_http_upstream_rr_peer_t     peer[1];  
  18. };  

函数的完整代码如下（ngx_http_upstream_round_robin.c）：
[cpp]  view plain copy print ?
  1. //函数：初始化服务器负载均衡表      
  2. //参数：  
  3. //us：ngx_http_upstream_main_conf_t结构体中upstreams数组元素  
  4. ngx_int_t  
  5. ngx_http_upstream_init_round_robin(ngx_conf_t *cf,  
  6.     ngx_http_upstream_srv_conf_t *us)  
  7. {  
  8.     ngx_url_t                      u;  
  9.     ngx_uint_t                     i, j, n, w;  
  10.     ngx_http_upstream_server_t    *server;  
  11.     ngx_http_upstream_rr_peers_t  *peers, *backup;  
  12.   
  13.     //回调指针设置  
  14.     us->peer.init = ngx_http_upstream_init_round_robin_peer;  
  15.   
  16.     //服务器数组指针不为空  
  17.     if (us->servers) {  
  18.         server = us->servers->elts;  
  19.   
  20.         n = 0;  
  21.         w = 0;  
  22.   
  23.     //遍历所有服务器  
  24.         for (i = 0; i < us->servers->nelts; i++) {  
  25.         //是后备服务器，跳过  
  26.             if (server[i].backup) {  
  27.                 continue;  
  28.             }  
  29.   
  30.         //服务器地址数量统计  
  31.             n += server[i].naddrs;  
  32.         //总的权重计算  
  33.             w += server[i].naddrs * server[i].weight;  
  34.         }  
  35.   
  36.         if (n == 0) {  
  37.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,  
  38.                           "no servers in upstream \"%V\" in %s:%ui",  
  39.                           &us->host, us->file_name, us->line);  
  40.             return NGX_ERROR;  
  41.         }  
  42.   
  43.     //为非后备服务器分配空间  
  44.         peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)  
  45.                               + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));  
  46.         if (peers == NULL) {  
  47.             return NGX_ERROR;  
  48.         }  
  49.   
  50.     //非后备服务器列表头中各属性设置  
  51.         peers->single = (n == 1);  
  52.         peers->number = n;  
  53.         peers->weighted = (w != n);  
  54.         peers->total_weight = w;  
  55.         peers->name = &us->host;  
  56.   
  57.         n = 0;  
  58.   
  59.     //后备服务器列表中各服务器项设置  
  60.         for (i = 0; i < us->servers->nelts; i++) {  
  61.             for (j = 0; j < server[i].naddrs; j++) {  
  62.                 if (server[i].backup) {  
  63.                     continue;  
  64.                 }  
  65.   
  66.                 peers->peer[n].sockaddr = server[i].addrs[j].sockaddr;  
  67.                 peers->peer[n].socklen = server[i].addrs[j].socklen;  
  68.                 peers->peer[n].name = server[i].addrs[j].name;  
  69.                 peers->peer[n].max_fails = server[i].max_fails;  
  70.                 peers->peer[n].fail_timeout = server[i].fail_timeout;  
  71.                 peers->peer[n].down = server[i].down;  
  72.                 peers->peer[n].weight = server[i].weight;  
  73.                 peers->peer[n].effective_weight = server[i].weight;  
  74.                 peers->peer[n].current_weight = 0;  
  75.                 n++;  
  76.             }  
  77.         }  
  78.   
  79.     //非后备服务器列表挂载的位置  
  80.         us->peer.data = peers;  
  81.   
  82.         /* backup servers */  
  83.     //后备服务器  
  84.         n = 0;  
  85.         w = 0;  
  86.   
  87.         for (i = 0; i < us->servers->nelts; i++) {  
  88.             if (!server[i].backup) {  
  89.                 continue;  
  90.             }  
  91.         //后备服务器地址数量统计  
  92.             n += server[i].naddrs;  
  93.         //后备服务器总权重计算  
  94.             w += server[i].naddrs * server[i].weight;  
  95.         }  
  96.   
  97.         if (n == 0) {  
  98.             return NGX_OK;  
  99.         }  
  100.   
  101.     //后备服务器列表地址空间分配  
  102.         backup = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)  
  103.                               + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));  
  104.         if (backup == NULL) {  
  105.             return NGX_ERROR;  
  106.         }  
  107.   
  108.         peers->single = 0;  
  109.     //后备服务器列表头中各属性设置  
  110.         backup->single = 0;  
  111.         backup->number = n;  
  112.         backup->weighted = (w != n);  
  113.         backup->total_weight = w;  
  114.         backup->name = &us->host;  
  115.   
  116.         n = 0;  
  117.   
  118.     //后备服务器列表中各服务器项设置  
  119.         for (i = 0; i < us->servers->nelts; i++) {  
  120.             for (j = 0; j < server[i].naddrs; j++) {  
  121.                 if (!server[i].backup) {  
  122.                     continue;  
  123.                 }  
  124.   
  125.                 backup->peer[n].sockaddr = server[i].addrs[j].sockaddr;  
  126.                 backup->peer[n].socklen = server[i].addrs[j].socklen;  
  127.                 backup->peer[n].name = server[i].addrs[j].name;  
  128.                 backup->peer[n].weight = server[i].weight;  
  129.                 backup->peer[n].effective_weight = server[i].weight;  
  130.                 backup->peer[n].current_weight = 0;  
  131.                 backup->peer[n].max_fails = server[i].max_fails;  
  132.                 backup->peer[n].fail_timeout = server[i].fail_timeout;  
  133.                 backup->peer[n].down = server[i].down;  
  134.                 n++;  
  135.             }  
  136.         }  
  137.   
  138.     //后备服务器挂载  
  139.         peers->next = backup;  
  140.   
  141.         return NGX_OK;  
  142.     }  
  143.   
  144.     //us参数中服务器指针为空，例如用户直接在proxy_pass等指令后配置后端服务器地址  
  145.     /* an upstream implicitly defined by proxy_pass, etc. */  
  146.   
  147.     if (us->port == 0) {  
  148.         ngx_log_error(NGX_LOG_EMERG, cf->log, 0,  
  149.                       "no port in upstream \"%V\" in %s:%ui",  
  150.                       &us->host, us->file_name, us->line);  
  151.         return NGX_ERROR;  
  152.     }  
  153.   
  154.     ngx_memzero(&u, sizeof(ngx_url_t));  
  155.   
  156.     u.host = us->host;  
  157.     u.port = us->port;  
  158.   
  159.     //IP地址解析  
  160.     if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {  
  161.         if (u.err) {  
  162.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,  
  163.                           "%s in upstream \"%V\" in %s:%ui",  
  164.                           u.err, &us->host, us->file_name, us->line);  
  165.         }  
  166.   
  167.         return NGX_ERROR;  
  168.     }  
  169.   
  170.     n = u.naddrs;  
  171.   
  172.     peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)  
  173.                               + sizeof(ngx_http_upstream_rr_peer_t) * (n - 1));  
  174.     if (peers == NULL) {  
  175.         return NGX_ERROR;  
  176.     }  
  177.   
  178.     peers->single = (n == 1);  
  179.     peers->number = n;  
  180.     peers->weighted = 0;  
  181.     peers->total_weight = n;  
  182.     peers->name = &us->host;  
  183.   
  184.     for (i = 0; i < u.naddrs; i++) {  
  185.         peers->peer[i].sockaddr = u.addrs[i].sockaddr;  
  186.         peers->peer[i].socklen = u.addrs[i].socklen;  
  187.         peers->peer[i].name = u.addrs[i].name;  
  188.         peers->peer[i].weight = 1;  
  189.         peers->peer[i].effective_weight = 1;  
  190.         peers->peer[i].current_weight = 0;  
  191.         peers->peer[i].max_fails = 1;  
  192.         peers->peer[i].fail_timeout = 10;  
  193.     }  
  194.   
  195.     us->peer.data = peers;  
  196.   
  197.     /* implicitly defined upstream has no backup servers */  
  198.   
  199.     return NGX_OK;  
  200. }  

选择后端服务器

针对一个客户端请求的初始化工作

全局初始化完成之后，当一个客户端请求过来时，Nginx就要选择合适的后端服务器来处理该请求。在正式开始选择前，Nginx还要单独为本轮选择做一些初始化（针对一个客户端请求，nginx会进行多次尝试选择，尝试全部失败后才返回502错误，所以注意一轮选择与一次选择的区别）。

在前面的函数ngx_http_upstream_init_round_robin()中设置的回调函数us->peer.init，它的调用位置是函数ngx_http_upstream_init_request中（ngx_http_upstream.c）：
[cpp]  view plain copy print ?
  1. static void  
  2. ngx_http_upstream_init_request(ngx_http_request_t *r)  
  3. {  
  4. ...  
  5. if (uscf->peer.init(r, uscf) != NGX_OK) {  
  6.         ngx_http_upstream_finalize_request(r, u,  
  7.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);  
  8.         return;  
  9.     }  
  10.   
  11.     ngx_http_upstream_connect(r, u);  
  12. }  

即在针对每个请求选择后端服务器之前被调用。

下面看看函数ngx_http_upstream_init_round_robin_peer()完成了哪些工作。
它除了完成初始化工作之外，另外的核心工作是设置回调指针。

函数ngx_http_upstream_init_round_robin_peer的完整代码（ngx_http_upstream_round_robin.c）：
[cpp]  view plain copy print ?
  1. //函数：  
  2. //功能：针对每个请求选择后端服务器前做一些初始化工作  
  3. ngx_int_t  
  4. ngx_http_upstream_init_round_robin_peer(ngx_http_request_t *r,  
  5.     ngx_http_upstream_srv_conf_t *us)  
  6. {  
  7.     ngx_uint_t                         n;  
  8.     ngx_http_upstream_rr_peer_data_t  *rrp;  
  9.   
  10.     rrp = r->upstream->peer.data;  
  11.   
  12.     if (rrp == NULL) {  
  13.         rrp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_rr_peer_data_t));  
  14.         if (rrp == NULL) {  
  15.             return NGX_ERROR;  
  16.         }  
  17.   
  18.         r->upstream->peer.data = rrp;  
  19.     }  
  20.   
  21.     rrp->peers = us->peer.data;  
  22.     rrp->current = 0;  
  23.   
  24.     //n取值为：非后备服务器和后备服务器列表中个数较大的那个值  
  25.     n = rrp->peers->number;  
  26.   
  27.     if (rrp->peers->next && rrp->peers->next->number > n) {  
  28.         n = rrp->peers->next->number;  
  29.     }  
  30.   
  31.     //如果n小于一个指针变量所能表示的范围  
  32.     if (n <= 8 * sizeof(uintptr_t)) {  
  33.     //直接使用已有的指针类型的data变量做位图（tried是位图，用来标识在一轮选择中，各个后端服务器是否已经被选择过）  
  34.         rrp->tried = &rrp->data;  
  35.         rrp->data = 0;  
  36.   
  37.     } else {  
  38.     //否则从内存池中申请空间  
  39.         n = (n + (8 * sizeof(uintptr_t) - 1)) / (8 * sizeof(uintptr_t));  
  40.   
  41.         rrp->tried = ngx_pcalloc(r->pool, n * sizeof(uintptr_t));  
  42.         if (rrp->tried == NULL) {  
  43.             return NGX_ERROR;  
  44.         }  
  45.     }  
  46.   
  47.     //回调函数设置  
  48.     r->upstream->peer.get = ngx_http_upstream_get_round_robin_peer;  
  49.     r->upstream->peer.free = ngx_http_upstream_free_round_robin_peer;  
  50.     r->upstream->peer.tries = rrp->peers->number;  
  51. #if (NGX_HTTP_SSL)  
  52.     r->upstream->peer.set_session =  
  53.                                ngx_http_upstream_set_round_robin_peer_session;  
  54.     r->upstream->peer.save_session =  
  55.                                ngx_http_upstream_save_round_robin_peer_session;  
  56. #endif  
  57.   
  58.     return NGX_OK;  
  59. }  

对后端服务器进行一次选择
对后端服务器做一次选择的逻辑在函数ngx_http_upstream_get_round_robin_peer内，流程图如下：
NGX负载均衡策略_第1张图片
代码如下：
[cpp]  view plain copy print ?
  1. //函数：  
  2. //功能：对后端服务器做一次选择  
  3. ngx_int_t  
  4. ngx_http_upstream_get_round_robin_peer(ngx_peer_connection_t *pc, void *data)  
  5. {  
  6.     ngx_http_upstream_rr_peer_data_t  *rrp = data;  
  7.   
  8.     ngx_int_t                      rc;  
  9.     ngx_uint_t                     i, n;  
  10.     ngx_http_upstream_rr_peer_t   *peer;  
  11.     ngx_http_upstream_rr_peers_t  *peers;  
  12.   
  13.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,  
  14.                    "get rr peer, try: %ui", pc->tries);  
  15.   
  16.     /* ngx_lock_mutex(rrp->peers->mutex); */  
  17.   
  18.     pc->cached = 0;  
  19.     pc->connection = NULL;  
  20.   
  21.     //如果只有一台后端服务器，Nginx直接选择并返回  
  22.     if (rrp->peers->single) {  
  23.         peer = &rrp->peers->peer[0];  
  24.   
  25.         if (peer->down) {  
  26.             goto failed;  
  27.         }  
  28.   
  29.     } else {  
  30.     //有多台后端服务器  
  31.         /* there are several peers */  
  32.     //按照各台服务器的当前权值进行选择  
  33.         peer = ngx_http_upstream_get_peer(rrp);  
  34.   
  35.         if (peer == NULL) {  
  36.             goto failed;  
  37.         }  
  38.   
  39.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,  
  40.                        "get rr peer, current: %ui %i",  
  41.                        rrp->current, peer->current_weight);  
  42.     }  
  43.   
  44.     //设置连接的相关属性  
  45.     pc->sockaddr = peer->sockaddr;  
  46.     pc->socklen = peer->socklen;  
  47.     pc->name = &peer->name;  
  48.   
  49.     /* ngx_unlock_mutex(rrp->peers->mutex); */  
  50.   
  51.     if (pc->tries == 1 && rrp->peers->next) {  
  52.         pc->tries += rrp->peers->next->number;  
  53.     }  
  54.   
  55.     return NGX_OK;  
  56.   
  57.     //选择失败，转向后备服务器  
  58. failed:  
  59.   
  60.     peers = rrp->peers;  
  61.   
  62.     if (peers->next) {  
  63.   
  64.         /* ngx_unlock_mutex(peers->mutex); */  
  65.   
  66.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0, "backup servers");  
  67.   
  68.         rrp->peers = peers->next;  
  69.         pc->tries = rrp->peers->number;  
  70.   
  71.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))  
  72.                 / (8 * sizeof(uintptr_t));  
  73.   
  74.         for (i = 0; i < n; i++) {  
  75.              rrp->tried[i] = 0;  
  76.         }  
  77.   
  78.         rc = ngx_http_upstream_get_round_robin_peer(pc, rrp);  
  79.   
  80.         if (rc != NGX_BUSY) {  
  81.             return rc;  
  82.         }  
  83.   
  84.         /* ngx_lock_mutex(peers->mutex); */  
  85.     }  
  86.   
  87.     /* all peers failed, mark them as live for quick recovery */  
  88.   
  89.     for (i = 0; i < peers->number; i++) {  
  90.         peers->peer[i].fails = 0;  
  91.     }  
  92.   
  93.     /* ngx_unlock_mutex(peers->mutex); */  
  94.   
  95.     pc->name = peers->name;  
  96.   
  97.     //如果后备服务器也选择失败，则返回NGX_BUSY  
  98.     return NGX_BUSY;  
  99. }  

后端服务器权值计算在函数ngx_http_upstream_get_peer中。
[cpp]  view plain copy print ?
  1. //按照当前各服务器权值进行选择  
  2. static ngx_http_upstream_rr_peer_t *  
  3. ngx_http_upstream_get_peer(ngx_http_upstream_rr_peer_data_t *rrp)  
  4. {  
  5.     time_t                        now;  
  6.     uintptr_t                     m;  
  7.     ngx_int_t                     total;  
  8.     ngx_uint_t                    i, n;  
  9.     ngx_http_upstream_rr_peer_t  *peer, *best;  
  10.   
  11.     now = ngx_time();  
  12.   
  13.     best = NULL;  
  14.     total = 0;  
  15.   
  16.     for (i = 0; i < rrp->peers->number; i++) {  
  17.     //计算当前服务器的标记位在位图中的位置  
  18.         n = i / (8 * sizeof(uintptr_t));  
  19.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));  
  20.   
  21.     //已经选择过，跳过  
  22.         if (rrp->tried[n] & m) {  
  23.             continue;  
  24.         }  
  25.   
  26.     //当前服务器对象  
  27.         peer = &rrp->peers->peer[i];  
  28.   
  29.     //当前服务器已宕机，排除  
  30.         if (peer->down) {  
  31.             continue;  
  32.         }  
  33.   
  34.     //根据指定一段时间内最大失败次数做判断  
  35.         if (peer->max_fails  
  36.             && peer->fails >= peer->max_fails  
  37.             && now - peer->checked <= peer->fail_timeout)  
  38.         {  
  39.             continue;  
  40.         }  
  41.   
  42.         peer->current_weight += peer->effective_weight;  
  43.         total += peer->effective_weight;  
  44.   
  45.         if (peer->effective_weight < peer->weight) {  
  46.             peer->effective_weight++;  
  47.         }  
  48.   
  49.         if (best == NULL || peer->current_weight > best->current_weight) {  
  50.             best = peer;  
  51.         }  
  52.     }  
  53.   
  54.     if (best == NULL) {  
  55.         return NULL;  
  56.     }  
  57.   
  58.     //所选择的服务器在服务器列表中的位置  
  59.     i = best - &rrp->peers->peer[0];  
  60.   
  61.     rrp->current = i;  
  62.   
  63.     n = i / (8 * sizeof(uintptr_t));  
  64.     m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));  
  65.   
  66.     //位图相应位置置位  
  67.     rrp->tried[n] |= m;  
  68.   
  69.     best->current_weight -= total;  
  70.     best->checked = now;  
  71.   
  72.     return best;  
  73. }  

要理解这个函数的工作原理，先要区分下表示服务的ngx_http_upstream_rr_peer_t结构体中的一下三个成员变量：
[cpp]  view plain copy print ?
  1. ngx_int_t                       current_weight;  
  2. ngx_int_t                       effective_weight;  
  3. ngx_int_t                       weight;  

网上搜索到的解释：
effective_weight相当于质量(来源于配置的weight)，current_weight相当于重量。前者反应本质，一般是不变的。current_weight是运行时的动态权值，它的变化基于effective_weight。但是effective_weight在其对应的peer服务异常时，会被调低，当服务恢复正常时，effective_weight会逐渐恢复到实际值（配置的weight）。

下面我们结合具体的代码来看。
它们在函数ngx_http_upstream_init_round_robin中被初始化：
[cpp]  view plain copy print ?
  1. for (i = 0; i < us->servers->nelts; i++) {  
  2.            for (j = 0; j < server[i].naddrs; j++) {  
  3.                if (server[i].backup) {  
  4.                    continue;  
  5.                }  
  6.   
  7.                peers->peer[n].weight = server[i].weight;  
  8.                peers->peer[n].effective_weight = server[i].weight;  
  9.                peers->peer[n].current_weight = 0;  
  10.                n++;  
  11.            }  
  12.        }  
  13.   
  14.        /* backup servers */  
  15.        for (i = 0; i < us->servers->nelts; i++) {  
  16.            for (j = 0; j < server[i].naddrs; j++) {  
  17.                if (!server[i].backup) {  
  18.                    continue;  
  19.                }  
  20.   
  21.                backup->peer[n].weight = server[i].weight;  
  22.                backup->peer[n].effective_weight = server[i].weight;  
  23.                backup->peer[n].current_weight = 0;  
  24.   
  25.                n++;  
  26.            }  
  27.        }  
  28.   
  29.     /* an upstream implicitly defined by proxy_pass, etc. */  
  30.    for (i = 0; i < u.naddrs; i++) {  
  31.        peers->peer[i].weight = 1;  
  32.        peers->peer[i].effective_weight = 1;  
  33.        peers->peer[i].current_weight = 0;  
  34.    }  

可以看到weight、effective_weight都是初始化为配置项中的weight值。current_weight初始化为0.

下面分析这三个变量在负载均衡过程中的变化。
weight的值在整个运行过程中不发生变化。
total变量记录了针对一个服务列表的一次轮询过程中轮询到的所有服务的effective_weight总和。在每一次针对服务列表的轮询之前会置为为0.
遍历服务列表的过程中，每遍历到一个服务，会在该服务的current_weight上加上其对应的effective_weight。这个是累加。如果对统一的服务列表进行另一次轮询，那么会在前面计算的current_weight的基础之上再加上effective_weight。
轮询策略是取current_weight最大的服务器。每次取到后端服务（用best表示）后，都会把该对象peer的current_weight减去total的值。因为该服务刚被选中过，因此要降低权值。
关于effective_weight的变化，有两处，一个是在函数ngx_http_upstream_get_peer中：
[cpp]  view plain copy print ?
  1. //服务正常，effective_weight 逐渐恢复正常      
  2. if (peer->effective_weight < peer->weight) {  
  3.     peer->effective_weight++;  
  4. }  

另一处是在释放后端服务的函数ngx_http_upstream_free_round_robin_peer中：
[cpp]  view plain copy print ?
  1. if (peer->max_fails) {  
  2.      //服务发生异常时，调低effective_weight  
  3.     peer->effective_weight -= peer->weight / peer->max_fails;  
  4. }  

权重高的会优先被选中，而且被选中的频率也更高。权重低的也会由于权重逐渐增长获得被选中的机会。

下面给出一个加权轮询的选择实例（来自http://blog.sina.com.cn/s/blog_7303a1dc01014i0j.html）：

selected server

current_weight beforeselected

current_weight afterselected

a

{ 5, 1, 2 }

{ -3, 1, 2 }

c

{ 2, 2, 4 }

{ 2, 2, -4 }

a

{ 7, 3, -2 }

{ -1, 3, -2 }

a

{ 4, 4, 0 }

{ -4, 4, 0 }

b

{ 1, 5, 2 }

{ 1, -3, 2 }

a

{ 6, -2, 4 }

{ -2, -2, 4 }

c

{ 3, -1, 6 }

{ 3, -1, -2 }

a

{ 8, 0, 0 }

{ 0, 0, 0 }


释放后端服务器

连接后端服务器并且正常处理当前客户端请求后需释放后端服务器。如果在某一轮选择里，某次选择的服务器因连接失败或请求处理失败而需要重新进行选择，那么这时候就需要做一些额外的处理。
[cpp]  view plain copy print ?
  1. //函数：  
  2. //功能：释放后端服务器  
  3. void  
  4. ngx_http_upstream_free_round_robin_peer(ngx_peer_connection_t *pc, void *data,  
  5.     ngx_uint_t state)  
  6. {  
  7.     ngx_http_upstream_rr_peer_data_t  *rrp = data;  
  8.   
  9.     time_t                       now;  
  10.     ngx_http_upstream_rr_peer_t  *peer;  
  11.   
  12.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,  
  13.                    "free rr peer %ui %ui", pc->tries, state);  
  14.   
  15.     /* TODO: NGX_PEER_KEEPALIVE */  
  16.   
  17.     //后端服务只有一个  
  18.     if (rrp->peers->single) {  
  19.         pc->tries = 0;  
  20.         return;  
  21.     }  
  22.   
  23.     peer = &rrp->peers->peer[rrp->current];  
  24.   
  25.     //在某一轮选择里，某次选择的服务器因连接失败或请求处理失败而需要重新进行选择  
  26.     if (state & NGX_PEER_FAILED) {  
  27.         now = ngx_time();  
  28.   
  29.         /* ngx_lock_mutex(rrp->peers->mutex); */  
  30.   
  31.     //已尝试失败次数加一  
  32.         peer->fails++;  
  33.         peer->accessed = now;  
  34.         peer->checked = now;  
  35.   
  36.     //如果有最大失败次数限制  
  37.         if (peer->max_fails) {  
  38.         //服务发生异常时，调低effective_weight  
  39.             peer->effective_weight -= peer->weight / peer->max_fails;  
  40.         }  
  41.   
  42.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,  
  43.                        "free rr peer failed: %ui %i",  
  44.                        rrp->current, peer->effective_weight);  
  45.   
  46.     //effective_weight总大于0  
  47.         if (peer->effective_weight < 0) {  
  48.             peer->effective_weight = 0;  
  49.         }  
  50.   
  51.         /* ngx_unlock_mutex(rrp->peers->mutex); */  
  52.   
  53.     } else {  
  54.   
  55.         /* mark peer live if check passed */  
  56.   
  57.         if (peer->accessed < peer->checked) {  
  58.             peer->fails = 0;  
  59.         }  
  60.     }  
  61.   
  62.     //ngx_peer_connection_t结构体中tries字段：  
  63.     //表示在连接一个远端服务器时，当前连接出现异常失败后可以重试的次数，也就是允许失败的次数  
  64.     if (pc->tries) {  
  65.         pc->tries--;  
  66.     }  
  67.   
  68.     /* ngx_unlock_mutex(rrp->peers->mutex); */  
  69. }  

整个加权轮询的流程

整个加权轮询的流程图如下：
NGX负载均衡策略_第2张图片
说明：
首先是全局初始化，由函数ngx_http_upstream_init_round_robin完成，它在函数ngx_http_upstream_init_main_conf中被调用，代码：
[cpp]  view plain copy print ?
  1. static char *  
  2. ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)  
  3. {      
  4. ...  
  5.     for (i = 0; i < umcf->upstreams.nelts; i++) {  
  6.         //全局初始化  
  7.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:  
  8.                                             ngx_http_upstream_init_round_robin;  
  9.   
  10.         if (init(cf, uscfp[i]) != NGX_OK) {  
  11.             return NGX_CONF_ERROR;  
  12.         }  
  13.     }  
  14. ...  
  15. }  
收到客户请求之后，针对当前请求进行初始化，完成此功能的函数是ngx_http_upstream_init_round_robin_peer，它在函数ngx_http_upstream_init_request中被调用：
[cpp]  view plain copy print ?
  1. static void  
  2. ngx_http_upstream_init_request(ngx_http_request_t *r)  
  3. {  
  4. ...  
  5. if (uscf->peer.init(r, uscf) != NGX_OK) {  
  6.         ngx_http_upstream_finalize_request(r, u,  
  7.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);  
  8.         return;  
  9.     }  
  10.   
  11.     ngx_http_upstream_connect(r, u);  
  12. }  
然后是针对每个请求选择后端服务器，实现此功能的函数是ngx_http_upstream_get_round_robin_peer。它在函数ngx_event_connect_peer中被调用：
[cpp]  view plain copy print ?
  1. //函数：连接后端upstream  
  2. ngx_int_t  
  3. ngx_event_connect_peer(ngx_peer_connection_t *pc)  
  4. {  
  5. ...  
  6.     //此处调用选择后端服务器功能函数ngx_http_upstream_get_round_robin_peer  
  7.     rc = pc->get(pc, pc->data);  
  8.     if (rc != NGX_OK) {  
  9.         return rc;  
  10.     }  
  11.   
  12.     s = ngx_socket(pc->sockaddr->sa_family, SOCK_STREAM, 0);  
  13. ...  
  14. }  
之后是测试连接ngx_http_upstream_test_connect。它在函数ngx_http_upstream_send_request被调用：
[cpp]  view plain copy print ?
  1. //函数：发送数据到后端upstream  
  2. static void  
  3. ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u)  
  4. {  
  5. ...  
  6.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {  
  7.         //测试连接失败  
  8.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);  
  9.         return;  
  10.     }  
  11. ...  
  12. }  

如果测试成功，继续后续处理，并释放后端服务器。
如果测试失败，调用ngx_http_upstream_next函数，这个函数可能再次调用peer.get调用别的连接。
[cpp]  view plain copy print ?
  1. static void  
  2. ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,  
  3.     ngx_uint_t ft_type)  
  4. {  
  5. ...  
  6.     if (u->peer.sockaddr) {  
  7.   
  8.         if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404) {  
  9.             state = NGX_PEER_NEXT;  
  10.         } else {  
  11.             state = NGX_PEER_FAILED;  
  12.         }  
  13.         //释放后端服务器  
  14.         u->peer.free(&u->peer, u->peer.data, state);  
  15.         u->peer.sockaddr = NULL;  
  16.     }  
  17. ...  
  18. if (status) {  
  19.         u->state->status = status;  
  20.   
  21.         if (u->peer.tries == 0 || !(u->conf->next_upstream & ft_type)) {  
  22.   
  23. #if (NGX_HTTP_CACHE)  
  24.   
  25.             if (u->cache_status == NGX_HTTP_CACHE_EXPIRED  
  26.                 && (u->conf->cache_use_stale & ft_type))  
  27.             {  
  28.                 ngx_int_t  rc;  
  29.   
  30.                 rc = u->reinit_request(r);  
  31.   
  32.                 if (rc == NGX_OK) {  
  33.                     u->cache_status = NGX_HTTP_CACHE_STALE;  
  34.                     rc = ngx_http_upstream_cache_send(r, u);  
  35.                 }  
  36.   
  37.                 ngx_http_upstream_finalize_request(r, u, rc);  
  38.                 return;  
  39.             }  
  40. #endif  
  41.             //结束请求  
  42.             ngx_http_upstream_finalize_request(r, u, status);  
  43.             return;  
  44.         }  
  45.     }  
  46. ...  
  47. //再次发起连接  
  48. ngx_http_upstream_connect(r, u);  
  49. }  

函数ngx_http_upstream_connect中会调用ngx_event_connect_peer，进而调用ngx_http_upstream_get_round_robin_peer再次选择后端服务器。

你可能感兴趣的:(【１４】Nginx)

  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 2022-07-08 保利学府里李楚怡1307022
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 一个历史事件和查理一世走上断头台有很大关系，这个事件是什么？ 王老师聊围棋
    今天我要讲的历史事件，查理一世被处死的始末。其实查理一世给被处死的时候，与一个事件有很大的联系。这个事件是“普莱德清洗”。提到这个事件，我们不得不提到一个人，这个人就是克伦威尔。可以说，查理一世能够走上断头台，克伦威尔有很大的功劳。为什么这么说呢。那我们就成英国内战的终结说起吧。我们都知道英国的内战是有保王党挑起来。在保王党军队一路凯歌进攻的同时。就在1645年6月14日，在纳西比荒原上进行最后的
  • 学习“论语”-第59天 春峰轩
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
  • 143234234123432 JhonKI 考研
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • 九月班级管理工作反思 追梦蜂
    这个月应该算是最难的一个月，我已N年没当班主任，然后我又开始当了。职称是一方面，想到我如果退休了，不能再接触学生了，那该是多么遗憾的事！我的学生梁*铭是我的榜样，她那么努力，那么拼，那么上进，为什么我不行？虽然我面临的工作很难，但是高考数学也不容易。她拿下来了！满分150分她考了146分！我目睹她的艰辛，她的拼搏！还有，我要为我的孩子做榜样，如何竭尽全力，实现梦想。还有，服务，为社会做事，也是会有
  • 928、在新冠的日子里（2）隔离 天使小鱼儿
    昨天YD全部人员核酸检测阴性。但是也都不能回家，要隔离14天，按规定执行。小红也是其中之一，今天是第三天，第二夜，门把手的源头还没有通报，在排查中。隔离措施是对的。是人？是物？是相似病毒？希望是虚惊一场。昨天，单位排长队，做核酸检测。我们都统一做了检测。现在出去做事，核酸检测是必须的。我今天也要外出做事，所以核酸检测也要提供。给小红准备了简单的替换衣服。我们也按规定执行。问闺蜜你们也都不回家吗？回
  • 2024.9.14 Python，差分法解决区间加法，消除游戏，压缩字符串 RaidenQ python游戏开发语言算法力扣
    1.区间加法假设你有一个长度为n的数组，初始情况下所有的数字均为0，你将会被给出k个更新的操作。其中，每个操作会被表示为一个三元组：[startIndex,endIndex,inc]，你需要将子数组A[startIndex…endIndex]（包括startIndex和endIndex）增加inc。请你返回k次操作后的数组。示例:输入:length=5,updates=[[1,3,2],[2,4,
  • 网络通信流程 记得开心一点啊 服务器网络运维
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
  • 高中抓住这两招，帮你实现从学渣到学霸的逆袭 以读攻独
    富兰克林曾说：“宝贝放错了地方便是废物。”一句话戳中了“位置”的重要性。大多数人，最初对位置的明显感受，似乎就来源于上高中时的座位：成绩好的，坐前排，那里安静，学习氛围浓，受关注度高；成绩差的坐后面，嘈杂，充斥着汗味、食品味、香水味，也经常被点名。所以，位置不仅代表了分数，也给你打上了“学渣”或“学霸”的标签。在《逆袭》这本书中，就真实地讲述一个参加了2014年高考的高中生，用三年的奋斗史，从班级
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • 光盘文件系统 (iso9660) 格式解析 穷人小水滴 光盘文件系统iso9660denoGNU/Linuxjavascript
    越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
  • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1) 穷人小水滴 游戏科幻设计
    游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 樵夫随笔 NO.1146吓了公交司机一大跳 痴信不改一书生
    傍晚，我把公交司机吓了一大跳！下班回家路上，先在公交车上读了会儿书，又写了篇文章，还有大约10分钟才到站，于是，靠在座椅上小眯一会儿。这一眯不要紧，直接眯到了终点站！而且，除我以外的所有人都下车后，司机直接关掉车厢内的灯，紧接着下车，关门儿，准备去厕所。这时，我被惊醒，拍打着玻璃，大喊“师傅……师傅……”司机师傅打开车门后的第一句话就是：“你可把我吓得够呛！”说说当时的情景：终点站设在一破旧的小院
  • ubuntu安装wordpress lissettecarlr
    1安装nginx网上安装方式很多，这就就直接用apt-get了apt-getinstallnginx不用启动啥，然后直接在浏览器里面输入IP:80就能看到nginx的主页了。如果修改了一些配置可以使用下列命令重启一下systemctlrestartnginx.service2安装mysql输入安装前也可以更新一下软件源，在安装过程中将会让你输入数据库的密码。sudoapt-getinstallmy
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • 我的一个小心愿，减肥20斤，有人一起吗 张晓晓ZXX
    我现在体重141斤，163cm，想减到120以内，不想吃减肥药，不喝奶昔，也不想买健身卡，就是希望通过一些运动的aPP进行训练和适当的节食，有人一起的吗？3月12号，我73公斤，现在70.9公斤，是通过咕咚app训练来的，但一个人太孤单，有一起的吗？我想知道除了小时候坚持一个月练习写字帖把字写好了，还能做什么锻炼一下自己的毅力，我也想知道100天之后，我能不能也达到理想的体重。接下来100天，愿意
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • vue 创建项目报错：command failed: npm install --loglevel error 那鱼、会飞 vue.jsvue-cli3
    这个问题其实很好解决，只是很多种情况，逐一排除即可。稳下心来~vuecli3创建项目我的node版本是node14.15.0，（永远不要尝试最新版本）node各种版本下载地址：以往的版本|Node.js(nodejs.org)vue/[email protected]@vue/[email protected]（注意vue/cli2和vue/cli3的下载命名有所改变，2是-形式，3是/形式）其实报错
  • 最简单将静态网页挂载到服务器上(不用nginx) 全能全知者 服务器nginx运维前端html笔记
    最简单将静态网页挂载到服务器上(不用nginx)如果随便弄个静态网页挂在服务器都要用nignx就太麻烦了，所以直接使用Apache来搭建一些简单前端静态网页会相对方便很多检查Web服务器服务状态：sudosystemctlstatushttpd#ApacheWeb服务器如果发现没有安装web服务器：安装Apache：sudoyuminstallhttpd启动Apache：sudosystemctl
  • 一台适合普通办公使用的电脑推荐thinkpadE475 sam_1c14
    图片发自App图片发自App缺点是内存只有4G。胜在便宜。14寸，很轻薄。给老婆买的。应该不能用来编程，会很慢的，真要用可以自己加根内存条，最大扩展到32G。图片发自App
  • 2023-01-14 完美雨神
    孩子若是平凡之辈，那就承欢膝下；若是出类拔萃，那就让其展翅高飞；接受孩子的平庸，就像孩子从来没有要求父母﹣-一定要多么优秀一样。穷不怪父，孝不比兄，苦不责妻，气不凶子。﹣一梁晓声
  • 孩子强迫症，厌学叛逆，家长怎么办？ 扶禾心理
    01最近，我们的公众号后台收到了很多家长的私信，很多家长说，孩子在进入青春期后，不知不觉竟然有强迫行为，特别容易钻牛角尖，沉迷网络，厌学，顶撞父母。他们为此很苦恼，不知道怎么办。强迫症正在成为儿童和青少年中常见的精神障碍之一。强迫症是一种长期逐步形成的心理问题，是一种慢性、难治性心理疾病。在这里，我们分享一些咨询实践及思路供家长参考，希望对更多的家长和孩子有帮助。一位家长私信我们说，她儿子14岁，
  • NPM私库搭建-verdaccio（Linux） Beam007 npmlinux前端
    1、安装nodelinux服务器安装nodea)、官网下载所需的node版本https://nodejs.org/dist/v14.21.0/b)、解压安装包若下载的是xxx.tar.xz文件，解压命令为tar-xvfxxx.tar.xzc)、修改环境变量修改：/etc/profile文件#SETPATHFORNODEJSexportNODE_HOME=NODEJS解压安装的路径exportPAT
  • 《爱情》 杜文霞
    杜文霞坚持原创分享第39天（20190214）图片发自App对爱情的认识我越来越清晰了。真正的爱情是成年人的游戏，双方在关系中是平等的。就像舒婷《致橡树》中写的：我如果爱你——绝不学痴情的鸟儿，为绿荫重复单调的歌曲；必须是你近旁的一株木棉，作为树的形象和你站在一起。我们共享雾霭、流岚、虹霓。仿佛永远分离，却又终身相依。爱情中的爱是相互的，是爱与被爱的流动，不是控制和占有。如果一方总觉得另一方“应该
  • 斟一小组鸡血视频 和自己一起成长
    http://m.v.qq.com/play/play.html?coverid=&vid=c0518henl2a&ptag=2_6.0.0.14297_copy有一种努力叫做靠自己http://m.v.qq.com/play/play.html?coverid=&vid=i0547o426g4&ptag=2_6.0.0.14297_copy世界最励志短片https://v.qq.com/x/pa
  • 正常化的同理 迷你旅客
    郑璐宜昌焦点网络中级七期原创持续分享第214天SBFT的同理方式除了反应来访者的感受之外，更会暗示事情有其他可能性的存在，以试图动摇来访者的负面感受，改变她的自我觉知。其原则包括：1、将来访者所说的内容以“过去式”的动词（如：加上“曾经”）进行回应，暗示现在的负向可以成为过去。2、把来访者所用的含绝对性、强烈性的字眼，换为严重程度较低或发生比例较少的用字。例如，来访者说：“每天总是觉得快要发疯了。
  • java短路运算符和逻辑运算符的区别 3213213333332132 java基础
    /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
  • Java异常那些不得不说的事 白糖_ javaexception
    一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
  • utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
  • JAVA Annotation之定义篇 周凡杨 java注解annotation入门注释
        Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
  • tomcat的多域名、虚拟主机配置 g21121 tomcat
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linuxcapistrano
    1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
  • log4j的用法 Harry642 javalog4j
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
  • mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oraclejave
    定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  
  • Hessian 简单例子 antlove javaWebservicehessian
    hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
  • 数据库对象的同义词和序列 百合不是茶 sql序列同义词ORACLE权限
    回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
  • 使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试mockitoPowermock
            实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
  • 精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle数据库plsql
    /* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
  • 【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
  • jquery-validation备忘 白糖_ jquerycssF#Firebug
    留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&
  • solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java多线程
    public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
  • 买房历程 cfyme
        2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
  • [军事与科技]制造大型太空战舰的前奏 comsci 制造
           天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关
  • dateformat dai_lm DateFormat
    "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
  • Hadoop如何实现关联计算 datamachine mapreducehadoop关联计算
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs
  • 用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
  • 中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
      本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
  • js去除空格，去除左右两端的空格 蕃薯耀 去除左右两端的空格js去掉所有空格js去除空格
    js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
  • SpringMVC4零配置--web.xml hanqunfeng springmvc4
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
  • 《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架UI
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
  • JQuery EasyUI 验证扩展 可怜的猫 jqueryeasyui验证
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
    1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
  • Jquery性能优化 r361251 JavaScriptjquery
    一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
  • 在eclipse项目中使用maven管理依赖 tjj006 eclipsemaven
    概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
  • 中国天气网省市级联页面 x125858805 级联
    1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他