Dubbo loadbalance(2) - RoundRobin

@Override
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(); // 总个数
    int maxWeight = 0; // 最大权重
    int minWeight = Integer.MAX_VALUE; // 最小权重
    final LinkedHashMap<Invoker<T>, IntegerWrapper> invokerToWeightMap = new LinkedHashMap<Invoker<T>, IntegerWrapper>();
    int weightSum = 0;
    for (int i = 0; i < length; i++) {
        int weight = NoahLeastActiveLoadBalance.getWeight(invokers.get(i), invocation);
        maxWeight = Math.max(maxWeight, weight); // 累计最大权重
        minWeight = Math.min(minWeight, 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--;
                }
            }
        }
    }
    // 取模轮循
    return invokers.get(currentSequence % length);
}

@Override
    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 List<Invoker<T>> nonZeroWeightedInvokers = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            int weight = NoahLeastActiveLoadBalance.getOriginalWeight(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) {
                nonZeroWeightedInvokers.add(invokers.get(i));
            }
        }
        AtomicPositiveInteger sequence = sequences.get(key);
        if (sequence == null) {
            sequences.putIfAbsent(key, new AtomicPositiveInteger());
            sequence = sequences.get(key);
        }

        if (maxWeight > 0 && minWeight < maxWeight) {
            AtomicPositiveInteger indexSeq = indexSeqs.get(key);
            if (indexSeq == null) {
                indexSeqs.putIfAbsent(key, new AtomicPositiveInteger(-1));
                indexSeq = indexSeqs.get(key);
            }
            length = nonZeroWeightedInvokers.size();
            AtomicInteger atomicCount=new AtomicInteger(1);

            //每个最大循环次数：invoker.size()
            while (true) {
                int index = indexSeq.incrementAndGet() % length;
                int currentWeight;
                if (index == 0) {
                    currentWeight = sequence.incrementAndGet() % maxWeight;
                    log.info("index:{},需要重新计算,currentWeight:{}", index, currentWeight);
                } else {
                    currentWeight = sequence.get() % maxWeight;
                }

                log.info("index:{},currentWeight:{}", index, currentWeight);
                atomicCount.incrementAndGet();

                if (NoahLeastActiveLoadBalance.getOriginalWeight(nonZeroWeightedInvokers.get(index), invocation) > currentWeight) {
                    log.info("sequences:{},选中的端口:{},循环次数:{}", sequence.get(), nonZeroWeightedInvokers.get(index).getUrl().getPort(), atomicCount.get());
                    log.info("==========over========");
                    return nonZeroWeightedInvokers.get(index);
                }
            }
        }
        // Round robin，所有的invoker权重相同，则进行普通轮训即可
        return invokers.get(sequence.getAndIncrement() % length);
    }

@Override
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
    // 获取url到weightRoundRobin映射表，如果为空，则创建一个新的
    String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
    ConcurrentMap<String, WeightedRoundRobin> map = methodWeightMap.computeIfAbsent(key, k -> new ConcurrentHashMap<>());
    int totalWeight = 0;
    long maxCurrent = Long.MIN_VALUE;
    long now = System.currentTimeMillis();
    Invoker<T> selectedInvoker = null;
    WeightedRoundRobin selectedWRR = null;
    for (Invoker<T> invoker : invokers) {
        String identifyString = invoker.getUrl().toIdentityString();
        int weight = NoahLeastActiveLoadBalance.getWeight(invoker, invocation);
        //检测当前Invoker是否有相应的WeightedRoundRobin,没有则创建
        WeightedRoundRobin weightedRoundRobin = map.computeIfAbsent(identifyString, k -> {
            WeightedRoundRobin wrr = new WeightedRoundRobin();
            // 设置Invoker 权重
            wrr.setWeight(weight);
            return wrr;
        });
        // Invoker 权重不等于weightedRoundRobin中保存的权重，说明权重变化，进行更新
        if (weight != weightedRoundRobin.getWeight()) {
            //weight changed
            weightedRoundRobin.setWeight(weight);
        }
        // CAS操作 cur = current+weight
        long cur = weightedRoundRobin.increaseCurrent();
        // 设置 lastUpdate，表示近期更新过
        weightedRoundRobin.setLastUpdate(now);
        if (cur > maxCurrent) {
            maxCurrent = cur;
            // 将具有最大current 权重的Invoker赋值给selectedInvoker
            selectedInvoker = invoker;
            // 将Invoker对应的weightedRoundRobin赋值给selectedWRR，后面用到
            selectedWRR = weightedRoundRobin;
        }
        //计算权重之和
        totalWeight += weight;
    }
    // 如果Invoker个数与ConcurrentMap<String, WeightedRoundRobin>的key个数不一致
    if (invokers.size() != map.size()) {
        //去除长时间未被更新的节点（60s）
        map.entrySet().removeIf(item -> now - item.getValue().getLastUpdate() > RECYCLE_PERIOD);
    }
    if (selectedInvoker != null) {
        // CAS操作，将最大权重的Invoker减去权重总和
        selectedWRR.sel(totalWeight);
        // 返回具有最大current的Invoker
        return selectedInvoker;
    }
    // should not happen here
    return invokers.get(0);
}