负载均衡算法: 简单轮询算法, 平滑加权轮询, 一致性hash算法, 随机轮询, 加权随机轮询, 最小活跃数算法(基于dubbo) java代码实现

直接上干活

    /**
     * @version 1.0.0
     * @@menu <p>
     * @date 2020/11/17 16:28
     */
    public class LoadBlance {
        static Map<String, Integer> serverWeightMap = new HashMap<>();
    
        static {
            serverWeightMap.put("192.168.1.100", 1);
            serverWeightMap.put("192.168.1.101", 8);
            // 权重为4
            serverWeightMap.put("192.168.1.102", 4);
            serverWeightMap.put("192.168.1.103", 9);
            serverWeightMap.put("192.168.1.104", 2);
            // 权重为3
            serverWeightMap.put("192.168.1.105", 3);
            serverWeightMap.put("192.168.1.106", 4);
            // 权重为2
            serverWeightMap.put("192.168.1.107", 2);
            serverWeightMap.put("192.168.1.108", 8);
            serverWeightMap.put("192.168.1.109", 6);
            serverWeightMap.put("192.168.1.110", 1);
        }
    
        public List<String> MapCasttoList() {
            //这里重新一个map,作为缓冲, 目的是避免服务器上下线带来的问题
            Map<String, Integer> serverMap = getServerMap();
            Set<String> strings = serverMap.keySet();
            List<String> list = new ArrayList<>();
            list.addAll(strings);
            return list;
        }
    
        private Map<String, Integer> getServerMap() {
            Map<String, Integer> serverMap = new HashMap<>();
            serverMap.putAll(serverWeightMap);
            return serverMap;
        }
    
        static AtomicInteger index = new AtomicInteger();
    
        //1: 简单的轮询算法:
        public String Round() {
            List<String> ipList = MapCasttoList();
            if (index.get() >= ipList.size()) {
                index.set(0);
            }
            return ipList.get(index.getAndIncrement() % ipList.size());
        }
    
    
        //2: 随机算法
        public String RandomLoadBlance() {
            List<String> ipList = MapCasttoList();
            int index = new Random().nextInt(ipList.size());
            return ipList.get(index);
        }
    
    
        //3: ip 的hash法: 将ip hash,
        public String IpHashLoadBlance() {
            List<String> ipList = MapCasttoList();
            //获取ipList, 然后计算HashCode, 之后和 size计算出对应的index
            List<Long> ipHashList = ipList.stream().map(ip -> myHashCode(ip)).collect(Collectors.toList());
            int i = new Random().nextInt(ipList.size());
            Long index = ipHashList.get(i) % ipList.size();
            return ipList.get(index.intValue());
        }
    
        //因为 hashCode方法会出现负数,所以这里使用自写的hashCode方法
        private static long myHashCode(String str) {
            long h = 0;
            if (h == 0) {
                int off = 0;
                char val[] = str.toCharArray();
                long len = str.length();
                for (long i = 0; i < len; i++) {
                    h = 31 * h + val[off++];
                }
            }
            return h;
        }

    /**
     * 4: 一致性hash 负载轮询算法
     * https://blog.csdn.net/weixin_43925277/article/details/107989585
     * 原理:  http://www.zsythink.net/archives/1182
     */
    static TreeMap<Integer, String> treeMap = new TreeMap<>();

    static {
        //这里使用的hash环,有1000个虚拟节点, 构建hash环
        List<String> serverIpList = MapCasttoList();
        for (String ip : serverIpList) {
            for (int i = 0; i < 1000; i++) {
                //这里的hash算法,是对 2 ^ 32 次方 取模
                int ipHashCode = FNVHash(ip + i);
                treeMap.put(ipHashCode, ip);
            }
        }
    }

    //str 这里的str 是指使用某个请求的标志(请求名,或者别的),来hash,最终命中hash环对应的ip
    public String consistencyHashLoadBlance(String str) {
        int hashCode = FNVHash(str);
        //找到比这个 hashCode 值大的所有子树
        SortedMap<Integer, String> tailSubMap = treeMap.tailMap(hashCode);
        if (tailSubMap == null) {
            //返回hash环的第一个节点 对应的ip
            return treeMap.get(treeMap.firstKey());
        }
        //否则返回 hash环中,这个 子树的第一个节点对应的ip
        return treeMap.get(tailSubMap.firstKey());
    }

    // 32位的 Fowler-Noll-Vo 哈希算法
    // https://en.wikipedia.org/wiki/Fowler–Noll–Vo_hash_function
    public static int FNVHash(String key) {
        final int p = 16777619;
        Long hash = 2166136261L;
        for (int idx = 0, num = key.length(); idx < num; ++idx) {
            hash = (hash ^ key.charAt(idx)) * p;
        }
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        if (hash < 0) {
            hash = Math.abs(hash);
        }
        return hash.intValue();
    }


    
        /**
         * 5: 基于权重的轮询算法: 平滑加权轮询算法, Nginx的默认轮询算法就是 加权轮询算法
         *  https://my.oschina.net/u/1267069/blog/4437331
         * <p>
         * 思路: 比如 A : 5 , B : 3 , C : 2   (服务器 A,B,C 对应权重分别是 5,3,2)
         * ip: A,B,C
         * weight: 5,3,2 (计算得到 totalWeight = 10)
         * currentWeight: 0,0,0 (当前ip的初始权重都为0)
         * <p>
         * 请求次数: |  currentWeight = currentWeight + weight  |  最大权重为  |  返回的ip为 |  最大的权重 - totalWeight,其余不变
         *      1   |           5,3,2    (0,0,0 + 5,3,2)       |     5      |      A     |      -5,3,2
         *      2   |           0,6,4    (-5,3,2 + 5,3,2)      |     6      |      B     |       0,-4,4
         *      3   |           5,-1,6    (0,-4,4 + 5,3,2)     |     6      |     C      |       5,-1,-4
         *      4   |          10,2,-2    (5,-1,-4 + 5,3,2)    |     10     |     A      |       0,2,-2
         *      5   |           5,5,0                          |     5      |     A      |       -5,5,0
         *      6   |           0,8,2                          |     8      |     B      |       0,-2,2
         *      7   |           5,1,4                          |     5      |     A      |       -5,1,4
         *      8   |           0,4,6                          |     6      |     C      |       0,4,-4
         *      9   |           5,7,-2                         |     7      |     B      |       5,-3,-2
         *      10  |           10,0,0                         |     10     |     A      |        0,0,0
         * <p>
         * 至此结束: 可以看到负载轮询的策略是: A,B,C,A,A,B,A,C,B,A,
         *
         *   循环获取到权重最大的节点,和总权重, 之后将这个权重最大节点的权重 - 总权重, 最后返回这个权重最大节点对应的ip
         */
        public String weightRound(List<ServerNode> serverNodeList) {
            ServerNode selectedServerNode = null;
            int maxWeight = 0;
            int totalWeight = 0;
            for (ServerNode serverNode : serverNodeList) {
                serverNode.incrementWeight();//获取节点的当前权重
                if (serverNode.currentWeight > maxWeight) {
                    //节点的当前权重 大于最大权重, 就将该节点当做是选中的节点
                    maxWeight = serverNode.currentWeight;
                    selectedServerNode = serverNode;
                }
                //计算总的权重
                totalWeight += serverNode.weight;
            }
            // 当循环结束的时候, selectedServerNode就是权重最大的节点,对应的权重为maxWeight,  总的权重为totalWeight
            if (selectedServerNode != null) {
                //将权重最大的这个节点,的权重值减去 总权重
                selectedServerNode.decrementTotal(totalWeight);
                //并返回这个权重对应的 ip
                return selectedServerNode.ip;
            }
            return "";
        }
    
        private List<ServerNode> getServerNodeList(Map<String, Integer> serverMap) {
            List<ServerNode> list = new ArrayList<>();
            for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
                ServerNode serverNode = new ServerNode(entry.getKey(), entry.getValue());
                list.add(serverNode);
            }
            return list;
        }
    
        private class ServerNode {
            String ip;
            int weight;//初始配置好的权重
            int currentWeight;//当前的权重,初始为 0
    
            public ServerNode(String ip, int weight) {
                this.ip = ip;
                this.weight = weight;
            }
    
            public void decrementTotal(int totalWeight) {
                currentWeight = currentWeight - totalWeight;
            }
    
            public void incrementWeight() {
                currentWeight = currentWeight + weight;
            }
    
            public void setCurrentWeight(int currentWeight) {
                this.currentWeight = currentWeight;
            }
        }
    
    
    
        /**
         * 6: 加权随机
         *  思路:  1: 一个ip的权重为5, 就将这个ip存到list中五次, 然后随机,  简单,但是有缺点 list会很大,执行效率低
         *
         *  思路:  2:  转换思路: 将每一个ip的权重转化为 X轴上的数字, 随机的数字,落在X轴的那个位置, 就返回这个位置对应的 ip
         *        比如: 192.168.1.100 , 3
         *             192.168.1.102 , 6
         *             192.168.1.105 , 4
         *        转换为X轴 为: 0--3-----9---13   可以看到这里需要获取所有权重之和
         *        产生的随机数为: 12 ,
         *        12 和 第一个ip的权重3 比较, 12 >= 3
         *        然后 12 - 3 = 9, 9 和第二个ip的权重6比较, 9 >= 6
         *        然后 9 - 6 =3 , 3 和第三个ip的权重4比较, 3 < 4 跳出---->说明随机的ip 是 192.168.1.105
         *
         * 这里实现思路2
         */
        public String weightRandom(){
            //1: 获取所有ip权重之和
            List<Integer> weightList = new ArrayList<>(getServerMap().values());
            int totalWeight = weightList.stream().mapToInt(e->e.intValue()).sum();
            //2: 产生一个随机数
            int index = new Random().nextInt(totalWeight);
            for (String ip : getServerMap().keySet()) {
                //2.1 获取这个ip对应的权重
                Integer weight = getServerMap().get(ip);
    
                if(index < weight){
                    return ip;
                }
                index = index - weight;
            }
            return "";
        }


        /**
         * 6 : 最小活跃数算法 (这里基于 dubbo的最小活跃数算法)
         * 什么是最小活跃数算法:
         * 一个服务器有一个活跃数active, 当处理一个请求时,active+1, 请求处理完active-1, 并发情况下,这个active的值越小,说明这台服务器性能高, 那么这台服务器就应该多处理些请求
         * <p>
         * 有三种情况
         * 1: 只有一个ip 活跃数最低,那么就返回这个ip
         * 2: 有多个ip 活跃数最低,且权重不同,返回权重最大的那个ip(权重最大的ip 有可能是多个, 这里返回第一个)
         * 3: 有多个ip 活跃数最低,且权重相同, 随机返回
         * <p>
         * 也有特殊情况,加入第一台服务器A,2000年买的,处理请求最大数为100, 第二台机器B,2010年买的处理请求最大数为500, 第三台机器C,2020年买的处理最大请求数为2000,对应的活跃数分别为:A-90, B-400,C-800,如果按照最小活跃数应该A机器
         * 处理请求会更多,但实际上C机器还能够处理1200个请求,所以最小活跃数算法,适用于各个机器性能相近, 处理请求的时间长短,取决于某个请求的计算复杂度
         * <p>
         * 实现思路:
         * 1: 循环list, 如果
         */
        public String leastActiveLoadBalance(List<Ip_active_weight> invokers) {
            int length = invokers.size();
            // 所有invoker活跃数中 最小的活跃数, 初始为-1
            int leastActive = -1;

            // 所有invoker活跃数中,活跃数最小,且相同的个数, 默认0个
            int leastCount = 0;

            // leastIndexes 这个数组存的是最小活跃数对应的下标,  leastIndexes的大小不一定为1, 因为有可能有多个ip对应的活跃数最小,且相同
            int[] leastIndexes = new int[length];

            // 用来存 每个ip对应的权重
            int[] weights = new int[length];

            // 所有 ip的 权重之和, 初始为0
            int totalWeight = 0;
            // 这是一个标准
            int firstWeight = 0;

            // 这是一个标志, 默认true 每一个最小活跃数相同的ip 权重都相同
            boolean sameWeight = true;
            for (int i = 0; i < length; i++) {
                Ip_active_weight invoker = invokers.get(i);
                //获取对应的活跃数
                int active = invoker.getActive();
                //获取对应的权重
                int afterWarmup = invoker.getWeight();
                // 先将权重保存起来
                weights[i] = afterWarmup;
                if (leastActive == -1 || active < leastActive) {
                    //更新 最小活跃数
                    leastActive = active;
                    // 最小的活跃数的个数 加1
                    leastCount = 1;
                    //将 当前invoker就是最小活跃数,将他对应的 下标存入 leastIndexes数组中
                    leastIndexes[0] = i;
                    //叠加总权重
                    totalWeight = afterWarmup;
                    //设置第一个权重,用来作比较,
                    firstWeight = afterWarmup;
                    sameWeight = true;
                } else if (active == leastActive) {
                    leastIndexes[leastCount++] = i;
                    totalWeight += afterWarmup;
                    if (sameWeight && afterWarmup != firstWeight) {
                        //权重不同,将标志位 设置为false, 根据权重大小返回,说明有多个ip,最小活跃数相同,权重不同,置为false, 按照权重大小返回
                        sameWeight = false;
                    }
                }
            }
            //跳出循环时候, 已经找到了 最小活跃数,的集合
            if (leastCount == 1) {
                //活跃数最小的只有一个,直接返回
                return invokers.get(leastIndexes[0]).getIp();
            }

            // sameWeight为false ,说明有多个ip 最小活跃数相同, 权重不同,
            if (!sameWeight && totalWeight > 0) {
                //这里用到的思想是:  X轴, 随机出来一个权重a,落到哪个区域内(a-权重 < 0, 就返回这个权重对应的 ip),
                int offsetWeight = new Random().nextInt(totalWeight);
                for (int i = 0; i < leastCount; i++) {
                    int leastIndex = leastIndexes[i];
                    offsetWeight -= weights[leastIndex];
                    if (offsetWeight < 0) {
                        return invokers.get(leastIndex).getIp();
                    }
                }
            }
            //所有的最小活跃数相同,且权重相同,随机返回
            return invokers.get(leastIndexes[new Random().nextInt(leastCount)]).getIp();
        }

        public List<Ip_active_weight> buildIpActiveWeightList() {
            Map<String, Integer> serverMap = getServerMap();
            List<Ip_active_weight> list = new ArrayList<>(serverMap.keySet().size());
            getServerMap().forEach((key, value) -> {
                Ip_active_weight ip_active_weight = new Ip_active_weight();
                ip_active_weight.setIp(key);
                //这里随机权重(1-10)
                ip_active_weight.setActive(new Random().nextInt(3) + 1);
                ip_active_weight.setWeight(value);
                list.add(ip_active_weight);
            });
            return list;
        }

        class Ip_active_weight {
            String ip;
            //活跃数
            int active;
            //权重
            int weight;

            public String getIp() {
                return ip;
            }

            public void setIp(String ip) {
                this.ip = ip;
            }

            public int getActive() {
                return active;
            }

            public void setActive(int active) {
                this.active = active;
            }

            public int getWeight() {
                return weight;
            }

            public void setWeight(int weight) {
                this.weight = weight;
            }

            @Override
            public String toString() {
                return "Ip_active_weight{" +
                        "ip='" + ip + '\'' +
                        ", active=" + active +
                        ", weight=" + weight +
                        '}';
            }
        }

        @Test
        public static void test01() {
            LoadBlance loadBlance = new LoadBlance();
            List<Ip_active_weight> invokes = loadBlance.buildIpActiveWeightList();
            for (Ip_active_weight invoke : invokes) {
                System.out.println(invoke);
            }
            System.out.println("_----------------------");
            for (int i = 0; i < 50; i++) {
                //模拟请求50次
                System.out.println(loadBlance.leastActiveLoadBalance(invokes));
            }
        }
    

        public static void main(String[] args) {
            LoadBlance loadBlance = new LoadBlance();
            Map<String, Integer> serverMap = new HashMap<>();
            serverMap.put("A",5);
            serverMap.put("B",3);
            serverMap.put("C",2);
            List<ServerNode> serverNodeList = loadBlance.getServerNodeList(serverMap);
            for (int i = 0; i < 50; i++) {//模拟请求50次
                System.out.println(loadBlance.weightRound(serverNodeList));
            }
        }
    
    
    }