RoundRobin LoadBalance

• 輪循，按公約後的權重設定輪循比率。

• 存在慢的提供者累積請求的問題，比如：第二臺機器很慢，但沒掛，當請求調到第二臺時就卡在那，久而久之，所有請求都卡在調到第二臺上。

1）獲取輪詢key  服務名+方法名

獲取可供呼叫的invokers個數length

設定最大權重的預設值maxWeight=0

設定最小權重的預設值minWeight=Integer.MAX_VALUE

2）遍歷所有Inokers，比較出得出maxWeight和minWeight

3）如果權重是不一樣的

根據key獲取自增序列

自增序列加一與最大權重取模預設得到currentWeigth

遍歷所有invokers篩選出大於currentWeight的invokers

設定可供呼叫的invokers的個數length

4）自增序列加一併與length取模，從invokers獲取invoker

public class RoundRobinLoadBalance extends AbstractLoadBalance {

    public static final String NAME = "roundrobin";

    private final ConcurrentMap<String, AtomicPositiveInteger> sequences = new ConcurrentHashMap<String, AtomicPositiveInteger>();

    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 LinkedHashMap<Invoker<T>, IntegerWrapper> invokerToWeightMap = new LinkedHashMap<Invoker<T>, IntegerWrapper>();
		//權重值總數
        int weightSum = 0;
        for (int i = 0; i < length; i++) {
			//獲取權重值
            int weight = getWeight(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) {
                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--;
                    }
                }
            }
        }
        // Round robin
		//直接輪詢找服務
        return invokers.get(currentSequence % length);
    }

    private static final class IntegerWrapper {
        private int value;

        public IntegerWrapper(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public void decrement() {
            this.value--;
        }
    }

}