dubbo负载均衡代码分析3(加权轮询策略)

    public static void main(String[] args) {
        //存储调用的方法和总的调用次数的map
         final ConcurrentMap<String, AtomicInteger> sequences = new ConcurrentHashMap<String, AtomicInteger>();
        //统计invoker 被调用次数map
         final ConcurrentMap<String, AtomicInteger> result = new ConcurrentHashMap<String, AtomicInteger>();
        //模拟方法三个invoker 分别为 a,b,c
        List<String> invokes=new ArrayList<String>(3);
        invokes.add("a");
        invokes.add("b");
        invokes.add("c");
        //存储invoker和权重的对应map
        final LinkedHashMap<String, AtomicInteger> invokerToWeightMap = new LinkedHashMap<String,AtomicInteger>();
         for(int i=0;i<21;i++){
             //每次调用都把模拟的权重重新放入
             invokerToWeightMap.put("a",new AtomicInteger(3));
             invokerToWeightMap.put("b",new AtomicInteger(6));
             invokerToWeightMap.put("c",new AtomicInteger(9));
             select(invokes,invokerToWeightMap,sequences,result);
         }
        //打印调用结果统计
         for(Map.Entry<String, AtomicInteger> r : result.entrySet()){
             System.out.println(r.getKey()+"被调用:"+r.getValue()+"次");
         }
        }

    private  static void  select(List<String> invokes,
                                 LinkedHashMap<String, AtomicInteger> invokerToWeightMap,
                                 ConcurrentMap<String, AtomicInteger> sequences,
                                 ConcurrentMap<String, AtomicInteger> result){
       //假设调用servcie.hello方法
        AtomicInteger sequence = sequences.get("service.hello");
        if (sequence == null) {
            //默认调用次数为0
            sequences.putIfAbsent("servcie.hello", new AtomicInteger(0));
            sequence = sequences.get("servcie.hello");
        }
        //调用次数+1
        int currentSequence = sequence.getAndIncrement();
        System.out.print("currentSequence:" + currentSequence);
        int maxWeight=9;//最大权重
        int minWeight=3;//最小权重
        int weightSum=18;//总权重
        if (maxWeight > 0 && minWeight < maxWeight) { // 走权重不一样逻辑。
            int mod = currentSequence % weightSum;
            System.out.print(" mod:" + mod);
            for (int i = 0; i < maxWeight; i++) {
                for (Map.Entry<String, AtomicInteger> each : invokerToWeightMap.entrySet()) {
                    final String k = each.getKey();
                    final AtomicInteger v = each.getValue();
                    if (mod == 0 && v.intValue() > 0) {
                        System.out.println(" selected:"+k);
                        AtomicInteger count = result.get(k);
                        if (count == null) {
                            result.putIfAbsent(k, new AtomicInteger(1));
                        }else{
                            count.incrementAndGet();
                        }
                        return;
                    }
                    if (v.intValue() > 0) {
                        v.decrementAndGet();
                        mod--;
                    }
                }
            }
        }

    }

 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(); // 总个数
        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 = 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) { // 权重不一样
            //取模操作，保证mod值域在[0,weightSum)
            int mod = currentSequence % weightSum;
            for (int i = 0; i < maxWeight; i++) {//maxWeight选最大权重，保证加上子循环
               // 即 maxWeight*（invoker个数）>mod 值。这个mod就可以减到0
                for (Map.Entry<Invoker<T>, IntegerWrapper> each : invokerToWeightMap.entrySet()) {
                    final Invoker<T> k = each.getKey();
                    final IntegerWrapper v = each.getValue();
                    //在一次选择过程后（mod--，权重--,mod==0结束），选下一个权重大于0的
                    if (mod == 0 && v.getValue() > 0) {
                        return k;
                    }
                    if (v.getValue() > 0) {
                        //基于mod,来说之前选过的，权重-1.mod--
                        v.decrement();
                        mod--;
                    }
                }
            }
        }
        // 权重一样   取模轮循 简单轮询
        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--;
        }
    }