Nginx版本：1.9.1

演算法介紹

當後端是快取伺服器時，經常使用一致性雜湊演算法來進行負載均衡。

使用一致性雜湊的好處在於，增減叢集的快取伺服器時，只有少量的快取會失效，回源量較小。

在nginx+ats / haproxy+squid等CDN架構中，nginx/haproxy所使用的負載均衡演算法便是一致性雜湊。

我們舉個例子來說明一致性雜湊的好處。

假設後端叢集包含三臺快取伺服器，A、B、C。

請求r1、r2落在A上。

請求r3、r4落在B上。

請求r5、r6落在C上。

使用一致性雜湊時，當快取伺服器B宕機時，r1/r2會仍然落在A上，r5/r6會仍然落在C上，

也就是說這兩臺伺服器上的快取都不會失效。r3/r4會被重新分配給A或者C，併產生回源。

使用其它演算法，當快取伺服器B宕機時，r1/r2不再落在A上，r5/r6不再落在C上了。

也就是說A、B、C上的快取都失效了，所有的請求都要回源。

這裡不介紹一致性雜湊演算法的基本原理，如果不瞭解，先花個10分鐘看下這篇文章：

在分析模組程式碼之前，先來看下nginx所實現的一致性雜湊演算法。

1. 初始化upstream塊

主要工作是建立和初始化真實節點、建立和初始化虛擬節點。

其中真實節點是使用round robin的方法建立的。

Q：總共有多少個虛擬節點，一個真實節點對應多少個虛擬節點？

累加真實節點的權重，算出總的權重值total_weight，虛擬節點的個數一般為total_weight * 160。

一個權重為weight的真實節點，對應的虛擬節點數為weight * 160。

Q：對於每一個真實節點，是如何建立其對應的虛擬節點的？

1. 真實節點的server成員是其server指令的第一個引數，首先把它解析為HOST和PORT。

    base_hash = crc32(HOST 0 PORT)

    一個真實節點對應weight * 160個虛擬節點，對於每個虛擬節點來說，base_hash都是一樣的。

2. 為了使每個虛擬節點的hash值都不同，又引入了PREV_HASH，它是上一個虛擬節點的hash值。

    hash = crc32(base_hash PREV_HASH)

3. 虛擬節點的server成員，指向真實節點的server成員。如此一來，通過比較虛擬節點和真實節點的

   server成員是否相同，可以判斷它們是否是相對應的。

建立和初始化好虛擬節點陣列後，對其中的虛擬節點按照hash值進行排序，對於hash值相同的虛擬節點，只保留第一個。

經過上述步驟，我們得到一個所有虛擬節點組成的陣列，其元素的hash值有序而不重複。也就是說，ring建立起來了。

2. 初始話請求的負載均衡資料

根據hash指令第一個引數的實時值KEY，KEY一般是$host$uri之類的，計算出本次請求的雜湊值。

hash = crc32(KEY)

根據請求的雜湊值，在虛擬節點陣列中，找到“順時針方向”最近的一個虛擬節點，其索引為i。

什麼叫順時針方向最近？就是point[i - 1].hash < hash <= point[i].hash。

本次請求就落在該虛擬節點上了，之後交由其對應的真實節點來處理。

3. 選取真實節點

在peer.init中，已經知道請求落在哪個虛擬節點上了。

在peer.get中，需要查詢虛擬節點對應的真實節點。

根據虛擬節點的server成員，在真實節點陣列中查詢server成員相同的、可用的真實節點。

如果找不到，那麼沿著順時針方向，繼續查詢下一個虛擬節點對應的真實節點。

如果找到了一個，那麼就是它了。

如果找到了多個，使用輪詢的方法從中選取一個。

4. 缺陷和改進

一個虛擬節點和一個真實節點，是依據它們的server成員來關聯的。

這會出現一種情況，一個虛擬節點對應了多個真實節點，因為：

如果server指令的第一個引數為域名，可能解析為多個真實節點，那麼這些真實節點的server成員都是一樣的。

對於一個請求，計算其KEY的hash值，順時針找到最近的虛擬節點後，發現該虛擬節點對應了多個真實節點。

使用哪個真實節點呢？本模組就使用輪詢的方法，來從多個真實節點中選一個。

但我們知道使用一致性雜湊的場景中，真實節點一般是快取伺服器。

一個虛擬節點對應多個真實節點，會導致一個檔案被快取在多個快取伺服器上。

這會增加磁碟的使用量，以及回源量，顯然不是我們希望看到的。

解決這個問題的方法其實很簡單，就是虛擬節點和真實節點通過name成員來建立關聯。

因為就算對應同一條server配置，server的第一個引數為域名，各個真實節點的name成員也是唯一的。

這樣一來，找到了一個虛擬節點，就能找到一個唯一的真實節點，不會有上述問題了。

資料結構

1. 真實節點

就是採用round robin演算法所建立的後端伺服器，型別為ngx_http_upstream_rr_peer_t。

需要注意的是，如果server指令的第一個引數是IP和埠，那麼一條server指令只對應一個真實節點。

如果server指令的第一個引數是域名，一條server指令可能對應多個真實節點。

它們的server成員是相同的，可以通過name成員區分。

struct ngx_http_upstream_rr_peer_s {
    struct sockaddr *sockaddr; /* 後端伺服器的地址 */
    socklen_t socklen; /* 地址的長度*/
    ngx_str_t name; /* 後端伺服器地址的字串，server.addrs[i].name */
    ngx_str_t server; /* server的名稱，server.name */
     
    ngx_int_t current_weight; /* 當前的權重，動態調整，初始值為0 */
    ngx_int_t effective_weight; /* 有效的權重，會因為失敗而降低 */
    ngx_int_t weight; /* 配置項指定的權重，固定值 */

    ngx_uint_t conns; /* 當前連線數 */

    ngx_uint_t fails; /* "一段時間內"，已經失敗的次數 */
    time_t accessed; /* 最近一次失敗的時間點 */
    time_t checked; /* 用於檢查是否超過了"一段時間" */

    ngx_uint_t max_fails; /* "一段時間內"，最大的失敗次數，固定值 */
    time_t fail_timeout; /* "一段時間"的值，固定值 */
    ngx_uint_t down; /* 伺服器永久不可用的標誌 */
    ...
    ngx_http_upstream_rr_peer_t *next; /* 指向下一個後端，用於構成連結串列 */
    ...
} ngx_http_upstream_rr_peer_t;

ngx_http_upstream_rr_peers_t表示一組後端伺服器，比如一個後端叢集。

struct ngx_http_upstream_rr_peers_s {
    ngx_uint_t number; /* 後端伺服器的數量 */
    ...
    ngx_uint_t total_weight; /* 所有後端伺服器權重的累加值 */

    unsigned single:1; /* 是否只有一臺後端伺服器 */
    unsigned weighted:1; /* 是否使用權重 */

    ngx_str_t *name; /* upstream配置塊的名稱 */

    ngx_http_upstream_rr_peers_t *next; /* backup伺服器叢集 */
    ngx_http_upstream_rr_peer_t *peer; /* 後端伺服器組成的連結串列 */
};

2. 虛擬節點

一個真實節點，一般會對應weight * 160個虛擬節點。

虛擬節點的server成員，指向它所歸屬的真實節點的server成員，如此一來找到了一個虛擬節點後，

就能找到其歸屬的真實節點。

但這裡有一個問題，通過一個虛擬節點的server成員，可能會找到多個真實節點，而不是一個。

因為如果server指令的第一個引數為域名，那麼多個真實節點的server成員都是一樣的。

typedef struct {
    uint32_t hash; /* 虛擬節點的雜湊值 */
    ngx_str_t *server; /* 虛擬節點歸屬的真實節點，對應真實節點的server成員 */
} ngx_http_upstream_chash_point_t;

typedef struct {
    ngx_uint_t number; /* 虛擬節點的個數 */
    ngx_http_upstream_chash_point_t point[1]; /* 虛擬節點的陣列 */
} ngx_http_upstream_chash_points_t;

typedef struct {
    ngx_http_complex_value_t key; /* 關聯hash指令的第一個引數，用於計算請求的hash值 */
    ngx_http_upstream_chash_points_t *points; /* 虛擬節點的陣列 */
} ngx_http_upstream_chash_points_t;

3. 請求的一致性雜湊資料

typedef struct {
    /* the round robin data must be first */
    ngx_http_upstream_rr_peer_data_t rrp; /* round robin的per request負載均衡資料 */
    ngx_http_upstream_hash_srv_conf_t *conf; /* server配置塊 */
    ngx_str_t key; /* 對於本次請求，hash指令的第一個引數的具體值，用於計算本次請求的雜湊值 */
    ngx_uint_t tries; /* 已經嘗試的虛擬節點數 */
    ngx_uint_t rehash; /* 本演算法不使用此成員 */
    uint32_t hash; /* 根據請求的雜湊值，找到順時方向最近的一個虛擬節點，hash為該虛擬節點在陣列中的索引 */
    ngx_event_get_peer_pt get_rr_peer; /* round robin演算法的peer.get函式 */
} ngx_http_upstream_hash_peer_data_t;

round robin的per request負載均衡資料。

typedef struct {
     ngx_http_upstream_rr_peers_t *peers; /* 後端叢集 */
     ngx_http_upstream_rr_peer_t *current; /* 當前使用的後端伺服器 */
     uintptr_t *tried; /* 指向後端伺服器的點陣圖 */
     uintptr_t data; /* 當後端伺服器的數量較少時，用於存放其點陣圖 */
} ngx_http_upstream_rr_peer_data_t;

指令的解析函式

在一個upstream配置塊中，如果有hash指令，且它只帶一個引數，則使用的負載均衡演算法為雜湊演算法，比如：

hash $host$uri;

在一個upstream配置塊中，如果有hash指令，且它帶了兩個引數，且第二個引數為consistent，則使用的

負載均衡演算法為一致性雜湊演算法，比如：

hash $host$uri consistent;

這說明hash指令所屬的模組ngx_http_upstream_hash_module同時實現了兩種負載均衡演算法，而實際上

雜湊演算法、一致性雜湊演算法完全可以用兩個獨立的模組來實現，它們本身並沒有多少關聯。

雜湊演算法的實現比較簡單，類似之前分析過的ip_hash，接下來分析的是一致性雜湊演算法。

hash指令的解析函式主要做了：

把hash指令的第一個引數，關聯到一個ngx_http_complex_value_t變數，之後可以通過該變數獲取引數的實時值。

指定此upstream塊中server指令支援的屬性。

根據hash指令攜帶的引數來判斷是使用雜湊演算法，還是一致性雜湊演算法。如果hash指令的第二個引數為"consistent"，

則表示使用一致性雜湊演算法，指定upstream塊的初始化函式uscf->peer.init_upstream。

static char *ngx_http_upstream_hash(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ngx_http_upstream_hash_srv_conf_t *hcf = conf;
    ngx_str_t *value;
    ngx_http_upstream_srv_conf_t *uscf;
    ngx_http_compile_complex_value_t ccv;

    value = cf->args->elts;
    ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

    /* 把hash指令的第一個引數，關聯到一個ngx_http_complex_value_t變數，
     * 之後可以通過該變數獲取引數的實時值。
     */
    ccv.cf = conf;
    ccv.value = &value[1];
    ccv.complex_value = &hcf->key;

    if (ngx_http_compile_complex_value(&ccv) != NGX_OK)
        return NGX_CONF_ERROR;

    /* 獲取所在的upstream{}塊 */
    uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
    if (uscf->peer.init_upstream)
        ngx_conf_log_error(NGX_LOG_WARN, cf, 0, "load balancing method redefined");

    /* 指定此upstream塊中server指令支援的屬性 */
    uscf->flags = NGX_HTTP_UPSTREAM_CREATE
        | NGX_HTTP_UPSTREAM_WEIGHT
        | NGX_HTTP_UPSTREAM_MAX_FAILS
        | NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
        | NGX_HTTP_UPSTREAM_DOWN;

    /* 根據hash指令攜帶的引數來判斷是使用雜湊演算法，還是一致性雜湊演算法。
     * 每種演算法都有自己的upstream塊初始化函式。
      */
    if (cf->args->nelts == 2)
        uscf->peer.init_upstream = ngx_http_upstream_init_hash;
    else if (ngx_strcmp(value[2].data, "consistent") == 0)
        uscf->peer.init_upstream = ngx_http_upstream_init_chash;
    else
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\"", &value[2]);

    return NGX_CONF_OK;
}

初始化upstream塊

執行完指令的解析函式後，緊接著會呼叫所有HTTP模組的init main conf函式。

在執行ngx_http_upstream_module的init main conf函式時，會呼叫所有upstream塊的初始化函式。

對於使用一致性雜湊的upstream塊，其初始化函式（peer.init_upstream）就是上一步中指定

ngx_http_upstream_init_chash，它主要做了：

呼叫round robin的upstream塊初始化函式來建立和初始化真實節點

指定per request的負載均衡初始化函式peer.init

建立和初始化虛擬節點陣列，使該陣列中的虛擬節點有序而不重複

static ngx_int_t ngx_http_upstream_init_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
{
    u_char *host, *port, c;
    size_t host_len, port_len, size;
    uint32_t hash, base_hash;
    ngx_str_t *server;
    ngx_uint_t npoints, i, j;
    ngx_http_upstream_rr_peer_t *peer;
    ngx_http_upstream_rr_peers_t *peers;
    ngx_http_upstream_chash_points_t *points;
    ngx_http_upstream_hash_srv_conf_t *hcf;
    union {
        uint32_t value;
        u_char byte[4];
    } prev_hash;

    /* 使用round robin的upstream塊初始化函式，建立和初始化真實節點 */
    if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK)
        return NGX_ERROR:

    /* 重新設定per request的負載均衡初始化函式 */
    us->peer.init = ngx_http_upstream_init_chash_peer;

    peers = us->peer.data; /* 真實節點的叢集 */
    npoints = peers->total_weight * 160;

    /* 一共建立npoints個虛擬節點 */
    size = sizeof(ngx_http_upstream_chash_points_t) + 
        sizeof(ngx_http_upstream_chash_point_t) * (npoints - 1);

    points = ngx_palloc(cf->pool, size);
    if (points == NULL)
        return NGX_ERROR;

    points->number = 0;

    /* 初始化所有的虛擬節點 */
    for (peer = peers->peer; peer; peer = peer->next) {
        server = &peer->server; /* server指令的第一個引數, server.name */
        
        /* Hash expression is compatible with Cache::Memcached::Fast:
         * crc32(HOST 0 PORT PREV_HASH).
         */
        if (server->len >= 5 && ngx_strncasecmp(server->data, (u_char *) "unix:", 5) == 0)
        {
            host = server->data + 5;
            host_len = server->len - 5;
            port = NULL;
            port_len = 0;
            goto done;
        }

        /* 把每個peer的server成員，解析為HOST和PORT */
        for (j = 0; j < server->len; j++) {
            c = server->data[server->len - j - 1];

            if (c == ":") {
                host = server->data;
                host_len = server->len - j - 1;
                port = server->data + server->len - j;
                port_len = j;
                goto done;
            }

            if (c < '0' || c > '9') /* 表示沒有指定埠 */
                break;
        }

        host = server->data;
        host_len = server->len;
        port = NULL;
        port_len = 0;

   done:
        /* 根據解析peer的server成員所得的HOST和PORT，計算虛擬節點的base_hash值 */
        ngx_crc32_init(base_hash);
        ngx_crc32_update(&base_hash, host, host_len);
        ngx_crc32_update(&base_hash, (u_char *) "", 1); /* 空字串包含字元\0 */
        ngx_crc32_update(&base_hash, port, port_len);
        
        /* 對於歸屬同一個真實節點的虛擬節點，它們的base_hash值相同，而prev_hash不同 */
        prev_hash.value = 0;
        npoints = peer->weight * 160;

        for (j = 0; j < npoints; j++) {
            hash = base_hash;
            ngx_crc32_update(&hash, prev_hash.byte, 4);
            ngx_crc32_final(hash);

            points->point[points->number].hash = hash; /* 虛擬節點的雜湊值 */
            points->point[points->number].server = server; /* 虛擬節點所歸屬的真實節點，對應真實節點的server成員 */
            points->number++;

#if (NGX_HAVE_LITTLE_ENDIAN)
           prev_hash.value = hash;
#else
           prev_hash.byte[0] = (u_char) (hash & 0xff);
           prev_hash.byte[1] = (u_char) ((hash >> 8) & 0xff);
           prev_hash.byte[2] = (u_char) ((hash >> 16) & 0xff);
           prev_hash.byte[3] = (u_char) ((hash >> 24) & 0xff);
#endif
        }   
    }

    /* 使用快速排序，使虛擬節點陣列的元素，按照其hash值從小到大有序 */
    ngx_qsort(points->point, points->number, sizeof(ngx_http_upstream_chash_point_t),
        ngx_http_upstream_chash_cmp_points);

    /* 如果虛擬節點陣列中，有多個元素的hash值相同，只保留第一個 */
    for (i = 0, j = 1; j < points->number; j++)
        if (points->point[i].hash != points->point[j].hash)
            points->point[++i] = points->point[j];

    /* 經過上述步驟後，虛擬節點陣列中的元素，有序而不重複 */
    points->number = i + 1;
   
    hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);
    hcf->points = points; /* 儲存虛擬節點陣列 */

    return NGX_OK;
}

static int ngx_libc_cdel ngx_http_upstream_chash_cmp_points(const void *one, const void *two)
{
    ngx_http_upstream_chash_point_t *first = (ngx_http_upstream_chash_point_t *) one;
    ngx_http_upstream_chash_point_t *second = (ngx_http_upstream_chash_point_t *) two;

    if (first->hash < second->hash)
        return -1;
    else if (first->hash > second->hash)
        return 1;
    else
        return 0;
}

初始化請求的負載均衡資料 

收到一個請求後，一般使用的反向代理模組（upstream模組）為ngx_http_proxy_module，

其NGX_HTTP_CONTENT_PHASE階段的處理函式為ngx_http_proxy_handler，在初始化upstream機制的

ngx_http_upstream_init_request函式中，呼叫在第二步中指定的peer.init，主要用於初始化請求的負載均衡資料。

對於一致性雜湊，peer.init例項為ngx_http_upstream_init_chash_peer，主要做了：

首先呼叫hash演算法的per request負載均衡初始化函式，建立和初始化請求的負載均衡資料。

重新指定peer.get，用於選取一個真實節點來處理本次請求。

獲取的本請求對應的hash指令的第一個引數值，計算請求的hash值。

尋找第一個hash值大於等於請求的雜湊值的虛擬節點，即尋找“順時針方向最近”的一個虛擬節點。

static ngx_int_t ngx_http_upstream_init_chash_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)
{
    uint32_t hash;
    ngx_http_upstream_hash_srv_conf_t *hcf;
    ngx_http_upstream_hash_peer_data_t *hp;

    /* 呼叫hash演算法的per request負載均衡初始化函式，建立和初始化請求的負載均衡資料 */
    if (ngx_http_upstream_init_hash_peer(r, us) != NGX_OK)
        return NGX_ERROR;

    /* 重新指定peer.get，用於選取一個真實節點 */
    r->upstream->peer.get = ngx_http_upstream_get_chash_peer;

    hp = r->upstream->peer.data;
    hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);

    /* 根據獲取的本請求對應的hash指令的第一個引數值，計算請求的hash值 */
    hash = ngx_crc32_long(hp->key.data, hp->key.len);

    /* 根據請求的hash值，找到順時針方向最近的一個虛擬節點，hp->hash記錄此虛擬節點
     * 在陣列中的索引。
     */
    hp->hash = ngx_http_upstream_find_chash_point(hcf->points, hash);

    return NGX_OK:
}

hash演算法的per request負載均衡初始化函式。

static ngx_int_t ngx_http_upstream_init_hash_peer(ngx_http_request_t *r, ngx_http_upstream_srv_conf_t *us)
{
    ngx_http_upstream_hash_srv_conf_t *hcf;
    ngx_http_upstream_hash_peer_data_t *hp;

    hp = ngx_palloc(r->pool, sizeof(ngx_http_upstream_hash_peer_data_t));
    if (hp == NULL)
        return NGX_ERROR:

    /* 呼叫round robin的per request負載均衡初始化函式 */
    r->upstream->peer.data = &hp->rrp;
    if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK)
        return NGX_ERROR;

    r->upstream->peer.get = ngx_http_upstream_get_hash_peer;
    hcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_hash_module);

   /* 獲取本請求對應的hash指令的第一個引數值，用於計算請求的hash值 */
    if (ngx_http_complex_value(r, &hcf->key, &hp->key) != NGX_OK)
        return NGX_ERROR;
    ...
    hp->conf = hcf;
    hp->tries = 0;
    hp->rehash = 0;
    hp->hash = 0;
    hp->get_rr_peer = ngx_http_upstream_get_round_robin_peer; /* round robin的peer.get函式 */

    return NGX_OK;
}

我們知道虛擬節點陣列是有序的，事先已按照虛擬節點的hash值從小到大排序好了。

現在使用二分查詢，尋找第一個hash值大於等於請求的雜湊值的虛擬節點，即“順時針方向最近”的一個虛擬節點。

static ngx_uint_t ngx_http_upstream_find_chash_point(ngx_http_upstream_chash_points_t *points, uint32_t hash)
{
    ngx_uint_t i, j, k;
    ngx_http_upstream_chash_point_t *point;
    
    /* find first point >= hash */

    point = &points->point[0];
    i = 0;
    j = points->number;'

    while(i < j) {
        k = (i + j) / 2;

        if (hash > point[k].hash)
            i = k + 1;
        else if (hash < point[k].hash)
            j = k;
         else
            return k;
    }

    return i;
}

選取一個真實節點

一般upstream塊中會有多個真實節點，那麼對於本次請求，要選定哪一個真實節點呢？

對於一致性雜湊演算法，選取真實節點的peer.get函式為ngx_http_upstream_get_chash_peer。

其實在peer.init中，已經找到了該請求對應的虛擬節點了：

根據請求對應的hash指令的第一個引數值，計算請求的hash值。

尋找第一個雜湊值大於等於請求的hash值的虛擬節點，即“順時針方向最近”的一個虛擬節點。

在peer.get中，需查詢此虛擬節點對應的真實節點。

根據虛擬節點的server成員，在真實節點陣列中查詢server成員一樣的且可用的真實節點。

如果找不到，那麼沿著順時針方向，繼續查詢下一個虛擬節點對應的真實節點。

如果找到一個真實節點，那麼就是它了。

如果找到多個真實節點，使用輪詢的方法從中選取一個。

static ngx_http_upstream_get_chash_peer(ngx_peer_connection_t *pc, void *data)
{
    ngx_http_upstream_hash_peer_data_t *hp = data; /* 請求的負載均衡資料 */
    time_t now;
    intptr_t m;
    ngx_str_t *server;
    ngx_int_t total;
    ngx_uint_t i, n, best_i;
    ngx_http_upstream_rr_peer_t *peer, *best;
    ngx_http_upstream_chash_point_t *point;
    ngx_http_upstream_chash_points_t *points;
    ngx_http_upstream_hash_srv_conf_t *hcf;
    ...
    pc->cached = 0;
    pc->connection = NULL:
    now = ngx_time();
    hcf = hp->conf;
    points = hcf->points; /* 虛擬節點陣列 */
    point = &points->point[0]; /* 指向第一個虛擬節點 */

    for ( ; ; ) {
        /* 在peer.init中，已根據請求的雜湊值，找到順時針方向最近的一個虛擬節點，
         * hash為該虛擬節點在陣列中的索引。
         * 一開始hash值肯定小於number，之後每嘗試一個虛擬節點後，hash++。取模是為了防止越界訪問。
         */
        server = point[hp->hash % points->number].server;
        best = NULL;
        best_i = 0;
        total = 0;

        /* 遍歷真實節點陣列，尋找可用的、該虛擬節點歸屬的真實節點(server成員相同)，
          * 如果有多個真實節點同時符合條件，那麼使用輪詢來從中選取一個真實節點。
          */
        for (peer = hp->rrp.peers->peer, i = 0; peer; peer = peer->next, i++) {
            /* 檢查此真實節點在狀態點陣圖中對應的位，為1時表示不可用 */
            n = i / (8 * sizeof(uintptr_t));
            m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));
            if (hp->rrp.tried[n] & m)
                continue;            

            /* server指令中攜帶了down屬性，表示後端永久不可用 */
            if (peer->down)
                continue;

            /* 如果真實節點的server成員和虛擬節點的不同，表示虛擬節點不屬於此真實節點 */
            if (peer->server.len != server->len || 
                ngx_strncmp(peer->server.data, server->data, server->len) != 0)
                continue;

           /* 在一段時間內，如果此真實節點的失敗次數，超過了允許的最大值，那麼不允許使用了 */
           if (peer->max_fails
                && peer->fails >= peer->max_fails
                && now - peer->checked <= peer->fail_timeout)
                continue;
        
            peer->current_weight += peer->effective_weight; /* 對每個真實節點，增加其當前權重 */
            total += peer->effective_weight; /* 累加所有真實節點的有效權重 */

            /* 如果之前此真實節點發生了失敗，會減小其effective_weight來降低它的權重。          
             * 此後又通過增加其effective_weight來恢復它的權重。          
             */        
            if (peer->effective_weight < peer->weight) 
                peer->effective_weight++;
        
            /* 選取當前權重最大者，作為本次選定的真實節點 */
            if (best == NULL || peer->current_weight > best->current_weight) {
                best = peer;
                best_i = i;
            }
        }

        /* 如果選定了一個真實節點 */
        if (best) {
            best->current_weight -= total; /* 如果使用了輪詢，需要降低選定節點的當前權重 */
            goto found;
        }

        hp->hash++; /* 增加虛擬節點的索引，即“沿著順時針方向” */
        hp->tries++; /* 已經嘗試的虛擬節點數 */

        /* 如果把所有的虛擬節點都嘗試了一遍，還找不到可用的真實節點 */
        if (hp->tries >= points->number)
            return NGX_BUSY;
    }

found: /* 找到了和虛擬節點相對應的、可用的真實節點了 */
    hp->rrp.current = best; /* 選定的真實節點 */
    /* 儲存選定的後端伺服器的地址，之後會向這個地址發起連線 */
    pc->sockaddr = peer->sockaddr;
    pc->socklen = peer->socklen;
    pc->name = &peer->name;
    best->conns++;

    /* 更新checked時間 */
    if (now - best->checked > best->fail_timeout)
        best->checked = now;

    n = best_i / (8 * sizeof(uintptr_t));
    m = (uintptr_t) 1 << best_i % (8 * sizeof(uintptr_t));

    /* 對於本次請求，如果之後需要再次選取真實節點，不能再選取同一個了 */    
    hp->rrp->tried[n] |= m;

    return NGX_OK;
}