LeastActive LoadBalance

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

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; 
    // 遍历所有 provider
    for (int i = 0; i < length; i++) {
        // 获取当前 provider
        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;
            }
        }
    }
   
    if (leastCount == 1) {
        // 如果只有一个最小则直接返回
        return invokers.get(leastIndexs[0]);
    }
    
    // 最小活跃数有多个 provider
    // 所有 provider 的权重不一致情况，
    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)]);
}