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

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

待解決的問題

爲了說明平滑加權輪詢調度的平滑性，使用以下 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；

那麼，調度算法可以描述爲：
1、初始每個實例 i 的 當前有效權重 CWi 爲 配置權重 Wi，並求得配置權重和 weightSum；
2、選出 當前有效權重 最大 的實例，將 當前有效權重 CWi 減去所有實例的 權重和 weightSum，且變量 currentPos 指向此位置；
3、將每個實例 i 的 當前有效權重 CWi 都加上 配置權重 Wi；
4、此時變量 currentPos 指向的實例就是需調度的實例；
5、每次調度重複上述步驟 2、3、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 個結點的權重是 xixi，設總權重爲 S=x1+x2+…+xnS=x1+x2+…+xn。選擇分兩步：
1、爲每個節點加上它的權重值；
2、選擇最大的節點減去總的權重值；

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

假設第 1 步後，最大的節點爲 j，則第 j 個節點減去 S。
所以第 2 步的數組爲 [x1,x2,…,xj−S,…,xn][x1,x2,…,xj−S,…,xn]。 執行完第 2 步後，數組的和爲：
x1+x2+…+xj−S+…+xn=>x1+x2+…+xn−S=S−S=0x1+x2+…+xj−S+…+xn=>x1+x2+…+xn−S=S−S=0

由此可見，每輪選擇第 1 步操作都是數組的總和加上 S，第 2 步總和再減去 S，所以每輪選擇完後的數組總和都爲 0。

假設總共執行 S 輪選擇，記第 i 個結點選擇 mimi 次。第 i 個結點的當前權重爲 wiwi。 假設節點 j 在第 t 輪（t < S）之前，已經被選擇了 xjxj 次，記此時第 j 個結點的當前權重爲 wj=t∗xj−xj∗S=(t−S)∗xj<0wj=t∗xj−xj∗S=(t−S)∗xj<0， 因爲 t 恆小於 S，所以 wj<0wj<0。

前面假設總共執行 S 輪選擇，則剩下 S-t 輪 j 都不會被選中，上面的公式 wj=(t−S)∗xj+(S−t)∗xj=0wj=(t−S)∗xj+(S−t)∗xj=0。 所以在剩下的選擇中，wjwj 永遠小於等於 0，由於上面已經證明任何一輪選擇後，數組總和都爲 0，則必定存在一個節點 k 使得 wk>0wk>0，永遠不會再選中節點 j。

由此可以得出，第 i 個結點最多被選中 xixi 次，即 mi<=ximi<=xi。
因爲 S=m1+m2+…+mnS=m1+m2+…+mn 且 S=x1+x2+…+xnS=x1+x2+…+xn。 所以，可以得出 mi==ximi==xi。

證明平滑性

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

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

假設 t=xi−1t=xi−1，此時第 i 個結點的當前權重爲 wi=t∗xi−t∗S=(xi−1)∗xi−(xi−1)∗Swi=t∗xi−t∗S=(xi−1)∗xi−(xi−1)∗S。證明下一輪的第 1 步執行完的值 wi+xiwi+xi 不是最大的即可。

wi+xi=>(xi−1)∗xi−(xi−1)∗S+xi=>wi+xi=>(xi−1)∗xi−(xi−1)∗S+xi=>
x2i−xi∗S+S=>(xi−1)∗(xi−S)+xixi2−xi∗S+S=>(xi−1)∗(xi−S)+xi

因爲 xixi 恆小於 S，所以 xi−S<=−1xi−S<=−1。 所以上面：
(xi−1)∗(xi−S)+xi<=(xi−1)∗−1+xi=−xi+1+xi=1(xi−1)∗(xi−S)+xi<=(xi−1)∗−1+xi=−xi+1+xi=1

所以第 t 輪後，再執行完第 1 步的值 wi+xi<=1wi+xi<=1。
如果這 t 輪剛好是最開始的 t 輪，則必定存在另一個結點 j 的值爲 xj∗txj∗t，所以有 wi+xi<=1<1∗t<xj∗twi+xi<=1<1∗t<xj∗t。所以下一輪肯定不會選中 i。

總結

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

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