Dubbo负载均衡：最少活跃数(LeastActive)的实现分析

「爱情、让人受尽委屈。」 2022-02-13 16:41 73阅读 0赞

# Dubbo负载均衡：最少活跃数(LeastActive)的实现分析 #

2017年05月07日 14:34:57 [FserSuN][] 阅读数：4580

# 最少活跃数的含义 #

**官方解释**：最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差，使慢的机器收到更少。

**例如**，每个服务维护一个活跃数计数器。当A机器开始处理请求，该计数器加1，此时A还未处理完成。若处理完毕则计数器减1。而B机器接受到请求后很快处理完毕。那么A,B的活跃数分别是1，0。当又产生了一个新的请求，则选择B机器去执行(B活跃数最小)，这样使慢的机器A收到少的请求。

# 最少活跃数的实现分析 #

LeastActiveLoadBalance 类实现了最小活跃负载均衡。   
![这里写图片描述][SouthEast]

实现代码如下。

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)]);
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55

这个算法，总体上可分为两部分。

1.  活跃数与权重统计。
2.  选择invoker。

## 活跃数与权重统计 ##

统计最少活跃invoker的数量，总权重，及当有多个最小活跃数相同的Invoker时其权重(weight)是否相等。

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;
                    }
                }
            }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21

## 选择invoker ##

如果具有最小活跃数的invoker只有一个，直接返回该Invoker。

if (leastCount == 1) {
                // 如果只有一个最小则直接返回
                return invokers.get(leastIndexs[0]);
            }

*  1
 *  2
 *  3
 *  4

如果最小活跃数的invoker有多个，且权重不相等同时总权重大于0，这是随机生成一个权重，范围在\[0，totalWeight) 间内。最后根据随机生成的权重，来选择invoker。

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);
                }
            }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11

例如有3个invoker，权重分别为100,200,300   
![这里写图片描述][SouthEast 1]   
经过前面的统计，记录了总权重是600，随机生成的权重范围是\[0,600) ，若随机值为180，那么用随机生成的权重180依次去A(100),B(200),C(300)的权重，当减到B时候结果 <= 0，因此选择B。

所以通过这种方法，即用随机权重值从前向后减每个invoker的权重，结果<=0说明落在哪个invoker的范围内，最终确定invoker。

如果不满足前面3中情况，则从最小活跃数相同的invoker中随机选择一个invoker。

// 如果权重相同或权重为0则均等随机
    return invokers.get(leastIndexs[random.nextInt(leastCount)]);

*  1
 *  2

# 活跃数的变化 #

活跃数的修改发生在com.alibaba.dubbo.rpc.filter.ActiveLimitFilter中。若未配置actives属性，则每进行一次调用前该invoker关联的活跃数加1，调用结束后活跃数减1。

beginCount对活跃数加1，endCount对活跃数减1。

long begin = System.currentTimeMillis();
                RpcStatus.beginCount(url, methodName);
                try {
                    Result result = invoker.invoke(invocation);
                    RpcStatus.endCount(url, methodName, System.currentTimeMillis() - begin, true);
                    return result;
                } catch (RuntimeException t) {
                    RpcStatus.endCount(url, methodName, System.currentTimeMillis() - begin, false);
                    throw t;
                }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10

如果使用LeastActive负载均衡，则需要启用ActiveLimitFilter，这样活跃数才会变化。

因此需要配置filter，filter 为 “activelimit”。

<dubbo:service interface="service.DemoService" protocol="in,out" ref = "demoService" loadbalance="leastactive" filter="activelimit"/>

*  1

dubbo中包含一些内置filter,其描述在如下文件。

![这里写图片描述][SouthEast 2]

[FserSuN]: https://me.csdn.net/Revivedsun
[SouthEast]: /images/20220213/62fd2483b76344459b9bea9d122183ad.png
[SouthEast 1]: /images/20220213/8fea9c0f0a6e4d7c851c898c5918f59c.png
[SouthEast 2]: /images/20220213/2ab7654a22a443338624863324241075.png