負載均衡算法 — 平滑加權輪詢

首發於 樊浩柏科學院

在 負載均衡算法 — 輪詢 一文中，咱們就指出了加權輪詢算法一個明顯的缺陷。即在某些特殊的權重下，加權輪詢調度會生成不均勻的實例序列，這種不平滑的負載可能會使某些實例出現瞬時高負載的現象，致使系統存在宕機的風險。爲了解決這個調度缺陷，就提出了 平滑加權輪詢 調度算法。

待解決的問題

爲了說明平滑加權輪詢調度的平滑性，使用如下 3 個特殊的權重實例來演示調度過程。

服務實例	權重值
192.168.10.1:2202	5
192.168.10.2:2202	1
192.168.10.3:2202	1

咱們已經知道經過 加權輪詢 算法調度後，會生成以下不均勻的調度序列。

請求	選中的實例
1	192.168.10.1:2202
2	192.168.10.1:2202
3	192.168.10.1:2202
4	192.168.10.1:2202
5	192.168.10.1:2202
6	192.168.10.2:2202
7	192.168.10.3:2202

接下來，咱們就使用平滑加權輪詢算法調度上述實例，看看生成的實例序列如何？

算法描述

假設有 N 臺實例 S = {S1, S2, …, Sn}，配置權重 W = {W1, W2, …, Wn}，有效權重 CW = {CW1, CW2, …, CWn}。每一個實例 i 除了存在一個配置權重 Wi 外，還存在一個當前有效權重 CWi，且 CWi 初始化爲 Wi；指示變量 currentPos 表示當前選擇的實例 ID，初始化爲 -1；全部實例的配置權重和爲 weightSum；

那麼，調度算法能夠描述爲：
一、初始每一個實例 i 的 當前有效權重 CWi 爲 配置權重 Wi，並求得配置權重和 weightSum；
二、選出 當前有效權重 最大 的實例，將 當前有效權重 CWi 減去全部實例的 權重和 weightSum，且變量 currentPos 指向此位置；
三、將每一個實例 i 的 當前有效權重 CWi 都加上 配置權重 Wi；
四、此時變量 currentPos 指向的實例就是需調度的實例；
五、每次調度重複上述步驟 二、三、4；

上述 3 個服務，配置權重和 weightSum 爲 7，其調度過程以下：

請求	選中前的當前權重	currentPos	選中的實例	選中後的當前權重
1	{5, 1, 1}	0	192.168.10.1:2202	{-2, 1, 1}
2	{3, 2, 2}	0	192.168.10.1:2202	{-4, 2, 2}
3	{1, 3, 3}	1	192.168.10.2:2202	{1, -4, 3}
4	{6, -3, 4}	0	192.168.10.1:2202	{-1, -3, 4}
5	{4, -2, 5}	2	192.168.10.3:2202	{4, -2, -2}
6	{9, -1, -1}	0	192.168.10.1:2202	{2, -1, -1}
7	{7, 0, 0}	0	192.168.10.1:2202	{0, 0, 0}
8	{5, 1, 1}	0	192.168.10.1:2202	{-2, 1, 1}

能夠看出上述調度序列分散是很是均勻的，且第 8 次調度時當前有效權重值又回到 {0, 0, 0}，實例的狀態同初始狀態一致，因此後續能夠一直重複調度操做。

此輪詢調度算法思路首先被 Nginx 開發者提出，見 phusion/nginx 部分。

代碼實現

這裏使用 PHP 來實現，源碼見 fan-haobai/load-balance 部分。

class SmoothWeightedRobin implements RobinInterface
{
    private $services = array();

    private $total;

    private $currentPos = -1;

    public function init(array $services)
    {
        foreach ($services as $ip => $weight) {
            $this->services[] = [
                'ip'      => $ip,
                'weight'  => $weight,
                'current_weight' => $weight,
            ];
        }
        $this->total = count($this->services);
    }

    public function next()
    {
        // 獲取最大當前有效權重實例的位置
        $this->currentPos = $this->getMaxCurrentWeightPos();

        // 當前權重減去權重和
        $currentWeight = $this->getCurrentWeight($this->currentPos) - $this->getSumWeight();
        $this->setCurrentWeight($this->currentPos, $currentWeight);

        // 每一個實例的當前有效權重加上配置權重
        $this->recoverCurrentWeight();

        return $this->services[$this->currentPos]['ip'];
    }
}

其中，getSumWeight()爲全部實例的配置權重和；getCurrentWeight()和 setCurrentWeight()分別用於獲取和設置指定實例的當前有效權重；getMaxCurrentWeightPos()求得最大當前有效權重的實例位置，實現以下：

public function getMaxCurrentWeightPos()
{
    $currentWeight = $pos = 0;
    foreach ($this->services as $index => $service) {
        if ($service['current_weight'] > $currentWeight) {
            $currentWeight = $service['current_weight'];
            $pos = $index;
        }
    }

    return $pos;
}

recoverCurrentWeight()用於調整每一個實例的當前有效權重，即加上配置權重，實現以下：

public function recoverCurrentWeight()
{
    foreach ($this->services as $index => &$service) {
        $service['current_weight'] += $service['weight'];
    }
}

須要注意的是，在配置services服務列表時，一樣須要指定其權重：

$services = [
    '192.168.10.1:2202' => 5,
    '192.168.10.2:2202' => 1,
    '192.168.10.3:2202' => 1,
];

數學證實

惋惜的是，關於此調度算法嚴謹的數學證實少之又少，不過網友 tenfy 給出的 安大神 證實過程，很是值得參考和學習。

證實權重合理性

假若有 n 個結點，記第 i 個結點的權重是 $x_i$，設總權重爲 $S = x_1 + x_2 + … + x_n$。選擇分兩步：
一、爲每一個節點加上它的權重值；
二、選擇最大的節點減去總的權重值；

n 個節點的初始化值爲 [0, 0, …, 0]，數組長度爲 n，值都爲 0。第一輪選擇的第 1 步執行後，數組的值爲 $[x_1, x_2, …, x_n]$。

假設第 1 步後，最大的節點爲 j，則第 j 個節點減去 S。
因此第 2 步的數組爲 $[x_1, x_2, …, x_j-S, …, x_n]$。 執行完第 2 步後，數組的和爲：
$x_1 + x_2 + … + x_j-S + … + x_n => x_1 + x_2 + … + x_n - S = S - S = 0$

因而可知，每輪選擇第 1 步操做都是數組的總和加上 S，第 2 步總和再減去 S，因此每輪選擇完後的數組總和都爲 0。

假設總共執行 S 輪選擇，記第 i 個結點選擇 $m_i$ 次。第 i 個結點的當前權重爲 $w_i$。 假設節點 j 在第 t 輪（t < S）以前，已經被選擇了 $x_j$ 次，記此時第 j 個結點的當前權重爲 $w_j = t \* x_j - x_j \* S = (t - S) \* x_j < 0$， 由於 t 恆小於 S，因此 $w_j < 0$。

前面假設總共執行 S 輪選擇，則剩下 S-t 輪 j 都不會被選中，上面的公式 $w_j = (t - S) \* x_j + (S - t) \* x_j = 0$。 因此在剩下的選擇中，$w_j$ 永遠小於等於 0，因爲上面已經證實任何一輪選擇後，數組總和都爲 0，則一定存在一個節點 k 使得 $w_k > 0$，永遠不會再選中節點 j。

由此能夠得出，第 i 個結點最多被選中 $x_i$ 次，即 $m_i <= x_i$。
由於 $S = m_1 + m_2 + … + m_n$ 且 $S = x_1 + x_2 + … + x_n$。 因此，能夠得出 $m_i == x_i$。

證實平滑性

證實平滑性，只要證實不要一直都是連續選擇那一個節點便可。

跟上面同樣，假設總權重爲 S，假如某個節點 i 連續選擇了 t（$t < x_i$） 次，只要存在下一次選擇的不是節點 i，便可證實是平滑的。

假設 $t = x_i - 1$，此時第 i 個結點的當前權重爲 $w_i = t \* x_i - t \* S = (x_i - 1) \* x_i - (x_i - 1) \* S$。證實下一輪的第 1 步執行完的值 $w_i + x_i$ 不是最大的便可。

$w_i + x_i => (x_i - 1) \* x_i - (x_i - 1) \* S + x_i =>$
$x_i^2 - x_i \* S + S => (x_i - 1) \* (x_i - S) + x_i$

由於 $x_i$ 恆小於 S，因此 $x_i - S <= -1$。 因此上面：
$(x_i - 1) \* (x_i - S) + x_i <= (x_i - 1) \* -1 + x_i = -x_i + 1 + x_i = 1$

因此第 t 輪後，再執行完第 1 步的值 $w_i + x_i <= 1$。
若是這 t 輪恰好是最開始的 t 輪，則一定存在另外一個結點 j 的值爲 $x_j \* t$，因此有 $w_i + x_i <= 1 < 1 \* t < x_j \* t$。因此下一輪確定不會選中 i。

總結

儘管，平滑加權輪詢算法改善了加權輪詢算法調度的缺陷，即調度序列分散的不均勻，避免了實例負載忽然加劇的可能，可是仍然不能動態感知每一個實例的負載。

若因爲實例權重配置不合理，或者一些其餘緣由加劇系統負載的狀況，平滑加權輪詢都沒法實現每一個實例的負載均衡，這時就須要 有狀態 的調度算法來完成。

相關文章 »

• 負載均衡算法 — 輪詢（2018-11-29）