dubbo負載均衡策略及對應源碼分析

在集羣負載均衡時，Dubbo 提供了多種均衡策略，缺省爲 random 隨機調用。咱們還能夠擴展本身的負責均衡策略，前提是你已經從一個小白變成了大牛，嘻嘻

一、Random LoadBalance

1.1 隨機，按權重設置隨機機率。

1.2 在一個截面上碰撞的機率高，但調用量越大分佈越均勻，並且按機率使用權重後也比較均勻，有利於動態調整提供者權重。

1.3 源碼分析

package com.alibaba.dubbo.rpc.cluster.loadbalance;

import java.util.List;
import java.util.Random;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.rpc.Invocation;
import com.alibaba.dubbo.rpc.Invoker;

/**
 * random load balance.
 *
 * @author qianlei
 * @author william.liangf
 */
public class RandomLoadBalance extends AbstractLoadBalance {

public static final String NAME = "random";

private final Random random = new Random();

 protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation    invocation) {
    int length = invokers.size(); // 總個數
    int totalWeight = 0; // 總權重
    boolean sameWeight = true; // 權重是否都同樣
    for (int i = 0; i < length; i++) {
        int weight = getWeight(invokers.get(i), invocation);
        totalWeight += weight; // 累計總權重
        if (sameWeight && i > 0
                && weight != getWeight(invokers.get(i - 1), invocation)) {
            sameWeight = false; // 計算全部權重是否同樣
        }
    }
    if (totalWeight > 0 && ! sameWeight) {
        // 若是權重不相同且權重大於0則按總權重數隨機
        int offset = random.nextInt(totalWeight);
        // 並肯定隨機值落在哪一個片段上
        for (int i = 0; i < length; i++) {
            offset -= getWeight(invokers.get(i), invocation);
            if (offset < 0) {
                return invokers.get(i);
            }
        }
    }
    // 若是權重相同或權重爲0則均等隨機
    return invokers.get(random.nextInt(length));
}

}

說明：從源碼能夠看出隨機負載均衡的策略分爲兩種狀況

a. 若是總權重大於0而且權重不相同，就生成一個1~totalWeight(總權重數)的隨機數，而後再把隨機數和全部的權重值一一相減獲得一個新的隨機數，直到隨機 數小於0，那麼此時訪問的服務器就是使得隨機數小於0的權重所在的機器

b. 若是權重相同或者總權重數爲0，就生成一個1~length(權重的總個數)的隨機數，此時所訪問的機器就是這個隨機數對應的權重所在的機器

二、RoundRobin LoadBalance

2.1 輪循，按公約後的權重設置輪循比率。

2.2 存在慢的提供者累積請求的問題，好比：第二臺機器很慢，但沒掛，當請求調到第二臺時就卡在那，長此以往，全部請求都卡在調到第二臺上。

2.3 源碼分析

package com.alibaba.dubbo.rpc.cluster.loadbalance;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.utils.AtomicPositiveInteger;
import com.alibaba.dubbo.rpc.Invocation;
import com.alibaba.dubbo.rpc.Invoker;

 /**
* Round robin load balance.
*
* @author qian.lei
* @author william.liangf
*/
public class RoundRobinLoadBalance extends AbstractLoadBalance {

public static final String NAME = "roundrobin"; 

private final ConcurrentMap<String, AtomicPositiveInteger> sequences = new ConcurrentHashMap<String, AtomicPositiveInteger>();

private final ConcurrentMap<String, AtomicPositiveInteger> weightSequences = new ConcurrentHashMap<String, AtomicPositiveInteger>();

protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
    String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
    int length = invokers.size(); // 總個數
    int maxWeight = 0; // 最大權重
    int minWeight = Integer.MAX_VALUE; // 最小權重
    for (int i = 0; i < length; i++) {
        int weight = getWeight(invokers.get(i), invocation);
        maxWeight = Math.max(maxWeight, weight); // 累計最大權重
        minWeight = Math.min(minWeight, weight); // 累計最小權重
    }
    if (maxWeight > 0 && minWeight < maxWeight) { // 權重不同
        AtomicPositiveInteger weightSequence = weightSequences.get(key);
        if (weightSequence == null) {
            weightSequences.putIfAbsent(key, new AtomicPositiveInteger());
            weightSequence = weightSequences.get(key);
        }
        int currentWeight = weightSequence.getAndIncrement() % maxWeight;
        List<Invoker<T>> weightInvokers = new ArrayList<Invoker<T>>();
        for (Invoker<T> invoker : invokers) { // 篩選權重大於當前權重基數的Invoker
            if (getWeight(invoker, invocation) > currentWeight) {
                weightInvokers.add(invoker);
            }
        }
        int weightLength = weightInvokers.size();
        if (weightLength == 1) {
            return weightInvokers.get(0);
        } else if (weightLength > 1) {
            invokers = weightInvokers;
            length = invokers.size();
        }
    }
    AtomicPositiveInteger sequence = sequences.get(key);
    if (sequence == null) {
        sequences.putIfAbsent(key, new AtomicPositiveInteger());
        sequence = sequences.get(key);
    }
    // 取模輪循
    return invokers.get(sequence.getAndIncrement() % length);
}

}

說明：從源碼能夠看出輪循負載均衡的算法是：

a. 若是權重不同時，獲取一個當前的權重基數，而後從權重集合中篩選權重大於當前權重基數的集合，若是篩選出的集合的長度爲1，此時所訪問的機器就是集合裏面的權重對應的機器

b. 若是權重同樣時就取模輪循

三、LeastActive LoadBalance

3.1 最少活躍調用數，相同活躍數的隨機，活躍數指調用先後計數差(調用前的時刻減去響應後的時刻的值)。

3.2 使慢的提供者收到更少請求，由於越慢的提供者的調用先後計數差會越大

3.3 對應的源碼

package com.alibaba.dubbo.rpc.cluster.loadbalance;

import java.util.List;
import java.util.Random;

import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.rpc.Invocation;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.RpcStatus;

/**
* LeastActiveLoadBalance
* 
* @author william.liangf
*/
public class LeastActiveLoadBalance extends AbstractLoadBalance {

public static final String NAME = "leastactive";

private final Random random = new Random();

protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
    int length = invokers.size(); // 總個數
    int leastActive = -1; // 最小的活躍數
    int leastCount = 0; // 相同最小活躍數的個數
    int[] leastIndexs = new int[length]; // 相同最小活躍數的下標
    int totalWeight = 0; // 總權重
    int firstWeight = 0; // 第一個權重，用於於計算是否相同
    boolean sameWeight = true; // 是否全部權重相同
    for (int i = 0; i < length; i++) {
        Invoker<T> invoker = invokers.get(i);
        int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // 活躍數
        int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // 權重
        if (leastActive == -1 || active < leastActive) { // 發現更小的活躍數，從新開始
            leastActive = active; // 記錄最小活躍數
            leastCount = 1; // 從新統計相同最小活躍數的個數
            leastIndexs[0] = i; // 從新記錄最小活躍數下標
            totalWeight = weight; // 從新累計總權重
            firstWeight = weight; // 記錄第一個權重
            sameWeight = true; // 還原權重相同標識
        } else if (active == leastActive) { // 累計相同最小的活躍數
            leastIndexs[leastCount ++] = i; // 累計相同最小活躍數下標
            totalWeight += weight; // 累計總權重
            // 判斷全部權重是否同樣
            if (sameWeight && i > 0 
                    && weight != firstWeight) {
                sameWeight = false;
            }
        }
    }
    // assert(leastCount > 0)
    if (leastCount == 1) {
        // 若是隻有一個最小則直接返回
        return invokers.get(leastIndexs[0]);
    }
    if (! sameWeight && totalWeight > 0) {
        // 若是權重不相同且權重大於0則按總權重數隨機
        int offsetWeight = random.nextInt(totalWeight);
        // 並肯定隨機值落在哪一個片段上
        for (int i = 0; i < leastCount; i++) {
            int leastIndex = leastIndexs[i];
            offsetWeight -= getWeight(invokers.get(leastIndex), invocation);
            if (offsetWeight <= 0)
                return invokers.get(leastIndex);
        }
    }
    // 若是權重相同或權重爲0則均等隨機
    return invokers.get(leastIndexs[random.nextInt(leastCount)]);
}
}

說明：源碼裏面的註釋已經很清晰了，大體的意思就是活躍數越小的的機器分配到的請求越多

四、ConsistentHash LoadBalance

4.1 一致性 Hash，相同參數的請求老是發到同一提供者。

4.2 當某一臺提供者掛時，本來發往該提供者的請求，基於虛擬節點，平攤到其它提供者，不會引發劇烈變更。

4.3 缺省只對第一個參數 Hash，若是要修改，請配置 <dubbo:parameter key="hash.arguments" value="0,1" />

4.4 缺省用 160 份虛擬節點，若是要修改，請配置 <dubbo:parameter key="hash.nodes" value="320" />

4.5 源碼分析暫時尚未弄懂，後面弄懂了再補充進來，有興趣的小夥伴能夠本身去看一下源碼，而後一塊兒交流一下心得

若是想免費學習Java工程化、高性能及分佈式、深刻淺出。微服務、Spring，MyBatis，Netty源碼分析的朋友能夠加個人Java進階羣：478030634，羣裏有阿里大牛直播講解技術，以及Java大型互聯網技術的視頻免費分享給你們。

五、dubbo官方的文檔的負載均衡配置示例

服務端服務級別

<dubbo:service interface="..." loadbalance="roundrobin" />

客戶端服務級別

<dubbo:reference interface="..." loadbalance="roundrobin" />

服務端方法級別

<dubbo:service interface="...">
  <dubbo:method name="..." loadbalance="roundrobin"/>
  </dubbo:service>

客戶端方法級別

<dubbo:reference interface="...">
  <dubbo:method name="..." loadbalance="roundrobin"/>
  </dubbo:reference>