Dubbo-负载均衡

1.前言

        在服务提供方是集群的时候，为了避免大量请求一直落到一个或者几个服务提供方机器上，从而使这些机器负载很高，甚至打死，需要做一定的负载均衡策略。Dubbo 提供了多种均衡策略，缺省为 random 随机调用。

 

2.负载均衡策略

2.1 随机策略(Random LoadBalance)

• 随机，按权重设置随机概率。
• 在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重

        RandomLoadBalance中会根据每个服务调用的权值次数来进行随机数，这样权值越大，动态调整越均衡。

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) {
            // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
			//如果权值不一样，则从总的权值中选择一个
            int offset = random.nextInt(totalWeight);
            // Return a invoker based on the random value.
            for (int i = 0; i < length; i++) {
				//不断的减去权值，当权值小于0时直接返回
                offset -= getWeight(invokers.get(i), invocation);
                if (offset < 0) {
                    return invokers.get(i);
                }
            }
        }
		//如果所有的服务的权值一样的话，直接随机并返回
        // If all invokers have the same weight value or totalWeight=0, return evenly.
        return invokers.get(random.nextInt(length));
    }
 
}

2.2 轮询策略(RoundRobin LoadBalance)

• 轮循，按公约后的权重设置轮循比率。
• 存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

public class RoundRobinLoadBalance extends AbstractLoadBalance {
 
    public static final String NAME = "roundrobin";
 
    private final ConcurrentMap<String, AtomicPositiveInteger> sequences = 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(); // Number of invokers
        int maxWeight = 0; // The maximum weight 最大权重值
        int minWeight = Integer.MAX_VALUE; // The minimum weight 最小权重支持，默认最大
        final LinkedHashMap<Invoker<T>, IntegerWrapper> invokerToWeightMap = new LinkedHashMap<Invoker<T>, IntegerWrapper>();
		//权重值总数
        int weightSum = 0;
        for (int i = 0; i < length; i++) {
			//获取权重值
            int weight = getWeight(invokers.get(i), invocation);
			//获取最大和最小权重值
            maxWeight = Math.max(maxWeight, weight); // Choose the maximum weight
            minWeight = Math.min(minWeight, weight); // Choose the minimum weight
            if (weight > 0) {
                invokerToWeightMap.put(invokers.get(i), new IntegerWrapper(weight));
                weightSum += weight;
            }
        }
        AtomicPositiveInteger sequence = sequences.get(key);
        if (sequence == null) {
            sequences.putIfAbsent(key, new AtomicPositiveInteger());
            sequence = sequences.get(key);
        }
        int currentSequence = sequence.getAndIncrement();
        if (maxWeight > 0 && minWeight < maxWeight) {
			//轮询当前值
            int mod = currentSequence % weightSum;
            for (int i = 0; i < maxWeight; i++) {
				//轮询当前值的余数轮询从服务中获取
                for (Map.Entry<Invoker<T>, IntegerWrapper> each : invokerToWeightMap.entrySet()) {
                    final Invoker<T> k = each.getKey();
                    final IntegerWrapper v = each.getValue();
                    if (mod == 0 && v.getValue() > 0) {
                        return k;
                    }
                    if (v.getValue() > 0) {
                        v.decrement();
                        mod--;
                    }
                }
            }
        }
        // Round robin
		//直接轮询找服务
        return invokers.get(currentSequence % length);
    }
 
    private static final class IntegerWrapper {
        private int value;
 
        public IntegerWrapper(int value) {
            this.value = value;
        }
 
        public int getValue() {
            return value;
        }
 
        public void setValue(int value) {
            this.value = value;
        }
 
        public void decrement() {
            this.value--;
        }
    }
 
}

2.3 最少活跃调用数 (LeastActive LoadBalance)

• 最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
• 使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

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]; // The index of invokers having the same least active value (leastActive)
        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; // 坐标id
                totalWeight = weight; // 权重
                firstWeight = weight; // 权重
                sameWeight = true; // 重新设置为权重相同
            } else if (active == leastActive) { // 如果活跃数相同，则记录权重
                leastIndexs[leastCount++] = i; // Record index number of this invoker
                totalWeight += weight; // Add this invoker's weight to totalWeight.
                // If every invoker has the same weight?
                if (sameWeight && i > 0
                        && weight != firstWeight) {
                    sameWeight = false;
                }
            }
        }
        // assert(leastCount > 0)
        if (leastCount == 1) {
            // If we got exactly one invoker having the least active value, return this invoker directly.
            return invokers.get(leastIndexs[0]);
        }
		//如果存在活跃数相关的服务，则随机一个权重值，看看权重值落到哪个服务中则返回某个服务
        if (!sameWeight && totalWeight > 0) {
            // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
            int offsetWeight = random.nextInt(totalWeight);
            // Return a invoker based on the random value.
            for (int i = 0; i < leastCount; i++) {
                int leastIndex = leastIndexs[i];
                offsetWeight -= getWeight(invokers.get(leastIndex), invocation);
                if (offsetWeight <= 0)
                    return invokers.get(leastIndex);
            }
        }
        // If all invokers have the same weight value or totalWeight=0, return evenly.
		//如果权重相同或权重为0则均等随机
        return invokers.get(leastIndexs[random.nextInt(leastCount)]);
    }
}

2.4 一致性hash策略 (ConsistentHash LoadBalance)

• 一致性 Hash，相同参数的请求总是发到同一提供者。
• 当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。
• 算法参见：http://en.wikipedia.org/wiki/Consistent_hashing
• 缺省只对第一个参数 Hash，如果要修改，请配置 <dubbo:parameter key="hash.arguments" value="0,1" />
• 缺省用 160 份虚拟节点，如果要修改，请配置 <dubbo:parameter key="hash.nodes" value="320" />

 

3.配置

3.1 服务端服务级别

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

3.2 客户端服务级别

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

3.3 服务端方法级别

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

3.4 客户端方法级别

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

 

4.负载均衡扩展

Dubbo提供了负载均衡的扩展机制

4.1 扩展接口：

com.alibaba.dubbo.rpc.cluster.LoadBalance

//默认负载均衡算法是random
@SPI(RandomLoadBalance.NAME)
public interface LoadBalance {
 
    /**
     * select one invoker in list.
     *
     * @param invokers   invokers.
     * @param url        refer url
     * @param invocation invocation.
     * @return selected invoker.
     */
	 //根据负载均衡算法获取将要调用的Invoker
    @Adaptive("loadbalance")
    <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;
 
}

4.2 扩展配置

<dubbo:protocol loadbalance="xxx" />
<!-- 缺省值设置，当<dubbo:protocol>没有配置loadbalance时，使用此配置 -->
<dubbo:provider loadbalance="xxx" />

4.3 已知扩展

com.alibaba.dubbo.rpc.cluster.loadbalance.RandomLoadBalance
com.alibaba.dubbo.rpc.cluster.loadbalance.RoundRobinLoadBalance
com.alibaba.dubbo.rpc.cluster.loadbalance.LeastActiveLoadBalance

4.4 扩展示例

Maven 项目结构：

src
 |-main
    |-java
        |-com
            |-xxx
                |-XxxLoadBalance.java (实现LoadBalance接口)
    |-resources
        |-META-INF
            |-dubbo
                |-com.alibaba.dubbo.rpc.cluster.LoadBalance (纯文本文件，内容为：xxx=com.xxx.XxxLoadBalance)

XxxLoadBalance.java：

package com.xxx;
 
import com.alibaba.dubbo.rpc.cluster.LoadBalance;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.Invocation;
import com.alibaba.dubbo.rpc.RpcException; 
 
public class XxxLoadBalance implements LoadBalance {
    public <T> Invoker<T> select(List<Invoker<T>> invokers, Invocation invocation) throws RpcException {
        // ...
    }
}

META-INF/dubbo/com.alibaba.dubbo.rpc.cluster.LoadBalance：

xxx=com.xxx.XxxLoadBalance