Dubbo源码学习--LeastActiveLoadBalance负载均衡（三）-蒲公英云

Dubbo源码学习--LeastActiveLoadBalance负载均衡（三）

桃扇骨 2022-05-28 00:42 288阅读 0赞

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