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

最少活跃数的含义

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

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

最少活跃数的实现分析

LeastActiveLoadBalance 类实现了最小活跃负载均衡。

实现代码如下。

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. 选择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;                }            }        }

选择invoker

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

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

如果最小活跃数的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);            }        }

例如有3个invoker，权重分别为100,200,300

经过前面的统计，记录了总权重是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)]);

活跃数的变化

活跃数的修改发生在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;            }

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

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

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

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