Dubbo 预热负载均衡 dubbo做负载均衡

转载

blueice 2024-03-25 08:54:09

文章标签 Dubbo 预热负载均衡负载均衡服务器 dubbo 权重 文章分类 运维

文章目录

负载均衡的介绍
负载均衡方式

软件负载均衡
硬件负载均衡

手撸负载均衡算法

随机算法-RandomLoadBalance

特点
代码实现

权重随机算法

方式一：权重数复制实现
方式二：区间范围实现

轮询算法-RoundRobinLoadBalance

特点
代码实现（简单的轮询算法）

平滑加权轮询

特点
代码实现

一致性哈希算法-ConsistentHashLoadBalance

特点
代码实现

最小活跃数算法-LeastActiveLoadBalance

特点
代码实现

Dubbo中负载均衡

最少活跃调用数

负载均衡的介绍

负载均衡，Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。

通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。

负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取重要数据，解决大量并发访问服务问题，这种集群技术可以用最少的投资获得接近于大型主机的性能。

负载均衡方式

分为软件负载均衡和硬件负载均衡

软件负载均衡

常见的软件负载均衡有Nginx、LVS、HAProxy

硬件负载均衡

常见的负载均衡硬件有Array、F5

手撸负载均衡算法

常见的负载均衡算法有：随机算法、加权轮询、一致性hash、最小活跃数算法

算法实现前提条件

定义一个服务器列表，每个负载均衡的算法会从中挑出一个服务器作为算法的结果。

public class ServerIps {

    //定义一个服务器列表
    public static final List<String> LIST = Arrays.asList(
            "192.168.0.1",
            "192.168.0.2",
            "192.168.0.3",
            "192.168.0.4",
            "192.168.0.5",
            "192.168.0.6",
            "192.168.0.7",
            "192.168.0.8",
            "192.168.0.9",
            "192.168.0.10"
    );
}

随机算法-RandomLoadBalance

特点

加权随机，按权重设置随机概率。
在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。
缺点：存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

代码实现

public class RandomLoadBalance {

    public static String getServer(){
        // 生成一个随机数作为list的下标值
        java.util.Random random = new java.util.Random();
        int randomPos = random.nextInt(ServerIps.LIST.size());

        return ServerIps.LIST.get(randomPos);
    }

    public static void main(String[] args) {
        //连续调用10次
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }
}

执行结果如下

192.168.0.3
192.168.0.3
192.168.0.5
192.168.0.3
192.168.0.1
192.168.0.7
192.168.0.5
192.168.0.6
192.168.0.3
192.168.0.8

当调用次数比较少时，Random产生的随机数可能会比较集中，此时多数请求会落到同一台服务器上，只有在经过多次请求后，才能使调用请求进行“均为”分配。调用量少这一点并没有什么关系，负载均衡机制正式为了应对请求量多的情况，所以随机算法是用的比较多的一种算法。

但是，上面的随机算法适用于每天机器的性能差不多的时候，实际上，生产中可能某些机器的性能更高一点，它可以处理更多的请求，所以，我们可以对每台服务器设置一个权重。
在ServerIps类中增加服务器权重对应关系map，权重之和为50：

//在ServerIps类中增加服务器权重对应关系map，权重之和为50：
    public static final Map<String, Integer> WEIGHT_LIST = new HashMap<String, Integer>();

    static {
        // 权重之和为50
        WEIGHT_LIST.put("192.168.0.1", 1);
        WEIGHT_LIST.put("192.168.0.2", 8);
        WEIGHT_LIST.put("192.168.0.3", 3);
        WEIGHT_LIST.put("192.168.0.4", 6);
        WEIGHT_LIST.put("192.168.0.5", 5);
        WEIGHT_LIST.put("192.168.0.6", 5);
        WEIGHT_LIST.put("192.168.0.7", 4);
        WEIGHT_LIST.put("192.168.0.8", 7);
        WEIGHT_LIST.put("192.168.0.9", 2);
        WEIGHT_LIST.put("192.168.0.10", 9);
    }

那么现在的随机算法变成了权重随机算法，当请求量比较多的时候，服务器使用的分布应该近似对应权重的分布。

权重随机算法

方式一：权重数复制实现

把每个服务器按它所对应的服务器权重数进行复制

public class WeightRandom {

    public static String getServer() {
        //生成一个随机数作为list的下标值
        List<String> ips = new ArrayList<String>();

        for (String ip : ServerIps.WEIGHT_LIST.keySet()) {
            Integer weight = ServerIps.WEIGHT_LIST.get(ip);

            //按权重进行服务器数量的复制
            for (int i = 0; i < weight; i++) {
                ips.add(ip);
            }
        }
        Random random = new Random();
        int randomPos = random.nextInt(ips.size());
        return ips.get(randomPos);
    }

    public static void main(String[] args) {
        //连续调用10次
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }
}

执行结果如下

192.168.0.6
192.168.0.10
192.168.0.10
192.168.0.6
192.168.0.4
192.168.0.2
192.168.0.6
192.168.0.2
192.168.0.4
192.168.0.6

这种实现方法在遇到权重之和特别大的时候就会比较消耗内存，因为需要对ip地址进行复制，权重之和越大，那么上文中的ips就需要越多的内存。

方式二：区间范围实现

假设我们有一组服务器servers=[A,B,C]，他们对应的权重为weights=[5,3,2]，权重总和为10。现在把这些权重值平铺在一维坐标值上，[0, 5) 区间属于服务器 A，[5, 8) 区间属于服务器 B，[8, 10) 区间属于服务器 C。接下来通过随机数生成器生成一个范围 [0, 10) 之间的随机数，然后计算在这个随机数会落在哪个区间上。比如数字3会落在服务器A对应的区间上，此时返回服务器A即可。权重越大的机器，在坐标轴上对应的区间范围就越大，因此随机数生成器生成的数字就会有更大的概率落在此区间内。只要随机数生成器产生的随机数分布性很好，在经过多次选择后，每个服务器被选中的次数比例接近其权重比例。

比如，经过一万次选择后，服务器A被选中的次数大约为5000次，服务器B被选中的次数约为3000次，服务器C被选中的次数约为2000次。

假设现在随机数offset=7;

offset<5 is false，所以不在[0, 5)区间，将offset = offset - 5（offset=2）
offset<3 is true，所以处于[5, 8)区间，所以应该选用B服务器

public class WeightRandomV2 {

    public static String getServer() {
        int totalWeight = 0;
        boolean sameWeight = true; //如果所有权重都相等，随机一个ip即可

        Object[] weights = ServerIps.WEIGHT_LIST.values().toArray();

        for (int i = 0; i < weights.length; i++) {

            Integer weight = (Integer) weights[i];

            totalWeight += weight;

            //判断权重是否都相等
            if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {
                sameWeight = false;
            }
        }
        Random random = new Random();

        int randomPos = random.nextInt(totalWeight);

        //权重值不相等
        if (!sameWeight) {
            for (String ip : ServerIps.WEIGHT_LIST.keySet()) {
                Integer value = ServerIps.WEIGHT_LIST.get(ip);
                if (randomPos < value) {
                    return ip;
                }
                randomPos = randomPos - value;
            }
        }
        return (String) ServerIps.WEIGHT_LIST.keySet().toArray()[new Random().nextInt(ServerIps.WEIGHT_LIST.size())];
    }


    public static void main(String[] args) {
        //连续调用10次
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }
}

轮询算法-RoundRobinLoadBalance

特点

加权轮询，按公约后的权重设置轮询比率，循环调用节点
缺点：同样存在慢的提供者累积请求的问题。

代码实现（简单的轮询算法）

public class RoundRobin {

    private static Integer pos = 0;

    public static String getServer() {
        String ip = "";

        //pos同步
        synchronized (pos) {
            if (pos >= ServerIps.LIST.size()) {
                pos = 0;
            }
            ip = ServerIps.LIST.get(pos);
            pos++;
        }
        return ip;
    }

    public static void main(String[] args) {
        //连续调用10次
        for (int i = 0; i < 11; i++) {
            System.out.println(getServer());
        }
    }
}

执行结果如下：

192.168.0.1
192.168.0.2
192.168.0.3
192.168.0.4
192.168.0.5
192.168.0.6
192.168.0.7
192.168.0.8
192.168.0.9
192.168.0.10
192.168.0.1

这种算法很简单，也很公平，每台服务轮流来进行服务，但是有的机器性能好，所以能者多劳，和随机算法一样，加上权重维度以后，其中一种实现方法就是复制法，复制法的缺点是，比较消耗内存。

介绍另外一种算法：这种算法引入一个概念：调用编号，比如第1次调用为1，第2次调用为2，第100次调用为100，调用编号是递增的，所以我们可以根据这个调用编号推算出服务器。

假设我们有三台服务器servers = [A, B, C]，对应的权重为 weights = [ 2, 5, 1], 总权重为8，我们可以理解为有8台“服务器”，这是8台“不具有并发功能”，其中有2台为A，5台为B，1台为C，一次调用过来的时候，需要按顺序访问，比如有10次调用，那么服务器调用顺序为AABBBBBCAA，调用编号会越来越大，而服务器是固定的，所以需要把调用编号“缩小”，这里对调用编号进行取余，除数为总权重和，

比如：

1号调用，1%8=1；
2号调用，2%8=2；
3号调用，3%8=3；
8号调用，8%8=0；
9号调用，9%8=1；
100号调用，100%8=4；
我们发现调用编号可以被缩小为0-7之间的8个数字，问题是怎么根据这个8个数字找到对应的服务器呢？和我们随机算法类似，这里也可以把权重想象为一个坐标轴“0-----2-----7-----8”
1号调用，1%8=1，offset = 1, offset <= 2 is true，取A；
2号调用，2%8=2；offset = 2，offset <= 2 is true, 取A;
3号调用，3%8=3；offset = 3, offset <= 2 is false, offset = offset - 2, offset = 1, offset <= 5，取B
8号调用，8%8=0；offset = 0, 特殊情况，offset = 8，offset <= 2 is false, offset = offset - 2, offset = 6, offset <= 5 is false, offset = offset - 5, offset = 1, offset <= 1 is true, 取C;
9号调用，9%8=1；// …
100号调用，100%8=4； //…

模拟调用编号获取工具：

public class Sequence {
    public static Integer num=0;

    public static Integer getAndIncrement(){
        return ++num;
    }

}

public class WeightRoundRobin {

    private static Integer pos = 0;

    public static String getServer() {
        int totalWeight = 0;

        boolean sameWeight = true;

        Object[] weights = ServerIps.WEIGHT_LIST.values().toArray();

        for (int i = 0; i < weights.length; i++) {
            Integer weight = (Integer) weights[i];

            totalWeight += weight;

            if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {
                sameWeight = false;
            }
        }
        Integer sequenceNum = Sequence.getAndIncrement();
        Integer offset = sequenceNum % totalWeight;

        offset = offset == 0 ? totalWeight : offset;

        if (!sameWeight) {
            for (String ip : ServerIps.WEIGHT_LIST.keySet()) {
                Integer weight = ServerIps.WEIGHT_LIST.get(ip);
                if (offset <= weight) {
                    return ip;
                }
                offset = offset - weight;
            }
        }
        String ip = "";
        synchronized (pos) {
            if (pos >= ServerIps.LIST.size()) {
                pos = 0;
            }
            ip = ServerIps.LIST.get(pos);
            pos++;
        }
        return ip;
    }

    public static void main(String[] args) {
        // 连续调用11次
        for (int i = 0; i < 11; i++) {
            System.out.println(getServer());
        }
    }
}

执行结果如下

192.168.0.2
192.168.0.2
192.168.0.2
192.168.0.2
192.168.0.2
192.168.0.2
192.168.0.2
192.168.0.2
192.168.0.1
192.168.0.4
192.168.0.4

但是这种算法有一个缺点：一台服务器的权重特别大的时候，他需要连续的的处理请求，但是实际上我们想达到的效果是，对于100次请求，只要有100*8/50=16次就够了，这16次不一定要连续的访问，比如假设我们有三台服务器 servers = [A, B, C]，对应的权重为 weights = [5, 1, 1] , 总权重为7，那么上述这个算法的结果是：AAAAABC，那么如果能够是这么一个结果呢：AABACAA，把B和C平均插入到5个A中间，这样是比较均衡的了。

我们这里可以改成平滑加权轮询。

平滑加权轮询

特点

思路：每个服务器对应两个权重，分别为weight 和currentWeight.其中weight是固定的，currentWeight会动态调整，初始值为0.当有新的请求进来时，遍历服务器列表，让它的currentWeight加上自身权重。遍历完成后，找到最大的 currentWeight，并将其减去权重总和，然后返回相应的服务器即可。
假设我们有三台服务器 servers = [A, B, C]，对应的权重为 weights = [5, 1, 1] , 总权重为7

请求编号	currentWeight 数组 (current_weight += weight)	选择结果(max(currentWeight))	减去权重总和后的currentWeight 数组（max(currentWeight) -= sum(weight))
1	[5, 1, 1]	A	[-2, 1, 1]
2	[3, 2, 2]	A	[-4, 2, 2]
3	[1, 3, 3]	B	[1, -4, 3]
4	[6, -3, 4]	A	[-1, -3, 4]
5	[4, -2, 5]	C	[4, -2, -2]
6	[9, -1, -1]	A	[2, -1, -1]
7	[7, 0, 0]	A	[0, 0, 0]

如上，经过平滑性处理后，得到的服务器序列为 [A, A, B, A, C, A, A]，相比之前的序列 [A, A, A, A, A, B, C]，分布性要好一些。初始情况下 currentWeight = [0, 0, 0]，第7个请求处理完后，currentWeight 再次变为 [0, 0, 0]。

代码实现

// 增加一个Weight类，用来保存ip, weight（固定不变的原始权重）, currentweight（当前会变化的权重）
public class Weight {
    private String ip;
    private Integer weight;
    private Integer currentWeight;

    public Weight(String ip, Integer weight, Integer currentWeight) {
        this.ip = ip;
        this.weight = weight;
        this.currentWeight = currentWeight;
    }

    public String getIp() {
        return ip;
    }

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

    public Integer getWeight() {
        return weight;
    }

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

    public Integer getCurrentWeight() {
        return currentWeight;
    }

    public void setCurrentWeight(Integer currentWeight) {
        this.currentWeight = currentWeight;
    }
}

public class WeightRoundRobinV2 {

    private static Map<String, Weight> weightMap = new HashMap<String, Weight>();

    public static String getServer() {
        // 获取权重之和
        int totalWeight = ServerIps.WEIGHT_LIST1.values().stream().reduce(0, (w1, w2) -> w1 + w2);

        //初始化weightMap，初始时将currentWeight赋值为weight
        if (weightMap.isEmpty()) {
            ServerIps.WEIGHT_LIST1.forEach((key, value) -> {
                weightMap.put(key, new Weight(key, value, value));
            });
        }
        //找出currentWeight最大值
        Weight maxCurrentWeight = null;
        for (Weight weight : weightMap.values()) {
            if (maxCurrentWeight == null || weight.getCurrentWeight() > maxCurrentWeight.getCurrentWeight()) {
                maxCurrentWeight = weight;
            }
        }

        //将maxCurrentWeight减去总权重和
        maxCurrentWeight.setCurrentWeight(maxCurrentWeight.getCurrentWeight() - totalWeight);

        //所有的ip的currentWeight统一加上原始权重
        for (Weight weight : weightMap.values()) {
            weight.setCurrentWeight(weight.getCurrentWeight() + weight.getWeight());
        }
        //返回maxCurrentWeight所对应的ip
        return maxCurrentWeight.getIp();
    }

    public static void main(String[] args) {
        // 连续调用10次
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }
}

ServerIps里添加数据WEIGHT_LIST1：

public static final Map<String, Integer> WEIGHT_LIST1 = new HashMap<String, Integer>();

    static {
        // 权重之和为50
        WEIGHT_LIST1.put("A", 5);
        WEIGHT_LIST1.put("B", 1);
        WEIGHT_LIST1.put("C", 1);
    }

执行结果如下：

A
A
B
A
C
A
A
A
A
B

一致性哈希算法-ConsistentHashLoadBalance

服务器集群接收到一次请求调用时，可以根据请求的信息，比如客户端的Ip地址，或请求路径与请求参数等信息进行哈希，可以得到一个哈希值，特点是对于相同的ip地址，或请求路径和请求参数哈希出来的值是不一样的，只要能再增加一个算法，能够把这个哈希值映射成一个服务端ip地址，就可以使相同的请求（相同的ip地址，或请求路径和请求参数）落到同一服务器上。

因为客户端发起的请求情况是无穷无尽的（客户端地址不同，请求参数不同等），所以对于的哈希值是无穷大的，所以我们不可能把所有的哈希值都进行映射到服务端ip上。所以这里用到了哈希环。

Dubbo 预热负载均衡 dubbo做负载均衡_Dubbo 预热负载均衡

哈希值如果需要ip1和ip2之间的，则应该选择ip2作为结果；
哈希值如果需要ip2和ip3之间的，则应该选择ip3作为结果；
哈希值如果需要ip3和ip4之间的，则应该选择ip4作为结果；
哈希值如果需要ip4和ip1之间的，则应该选择ip1作为结果；

上面这情况是比较均匀情况，如果出现ip4服务器不存在，那就是这样了：

Dubbo 预热负载均衡 dubbo做负载均衡_Dubbo 预热负载均衡_02

通过图片会发现，ip3和ip1直接的范围是比较大的，会有更多的请求落在ip1上，这是不“公平的”，解决这个问题需要加入虚拟节点，比如：

Dubbo 预热负载均衡 dubbo做负载均衡_负载均衡_03

其中ip2-1, ip3-1就是虚拟结点，并不能处理节点，而是等同于对应的ip2和ip3服务器。

实际上，这只是处理这种不均衡性的一种思路，实际上就算哈希环本身是均衡的，你也可以增加更多的虚拟节点来使这个环更加平滑，比如：

Dubbo 预热负载均衡 dubbo做负载均衡_负载均衡_04

这个彩环也是“公平的”，并且只有ip1,2,3,4是实际的服务器ip，其他的都是虚拟ip。

特点

一致性 Hash，相同参数的请求总是发到同一提供者。
当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。

代码实现

对于我们的服务端ip地址，我们肯定知道总共有多少个，需要多少个虚拟节点也有我们自己控制，虚拟节点越多则流量越均衡，另外哈希算法也是很关键的，哈希算法越散列流量也将越均衡。

public class ConsistentHash {

    private static SortedMap<Integer, String> virtualNodes = new TreeMap<>();

    private static final int VIRTUAL_NODES = 160;

    static {
        //对每个真实节点添加虚拟节点，虚拟节点会根据哈希算法进行散列
        for (String ip : ServerIps.LIST) {
            for (int i = 0; i < VIRTUAL_NODES; i++) {
                int hash = getHash(ip + "VN" + 1);
                virtualNodes.put(hash, ip);
            }
        }
    }

    private static int getHash(String str) {
        final int p = 16777619;
        int hash = (int) 2166136261L;

        for (int i = 0; i < str.length(); i++) {
            hash = (hash ^ str.charAt(i)) * 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;
    }

    private static String getServer(String client) {
        int hash = getHash(client);
        // 得到大于该Hash值的排好序的Map
        SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);
        // 大于该hash值的第一个元素的位置
        Integer nodeIndex = subMap.firstKey();

        // 如果不存在大于该hash值的元素，则返回根节点
        if (nodeIndex == null) {
            nodeIndex = virtualNodes.firstKey();
        }
        // 返回对应的虚拟节点名称
        return subMap.get(nodeIndex);
    }

    public static void main(String[] args) {
        // 连续调用10次,随机10个client
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer("client" + i));
        }
    }
}

运行结果如下：

192.168.0.4
192.168.0.3
192.168.0.2
192.168.0.7
192.168.0.7
192.168.0.10
192.168.0.5
192.168.0.4
192.168.0.5
192.168.0.4

最小活跃数算法-LeastActiveLoadBalance

前面几种方法主要目标是使服务端分配到的调用次数尽量均衡，但是实际情况是这样吗？调用次数相同，服务器的负载就均衡吗？当然不是，这里还要考虑每次调用的时间，而最小活跃数算法则是解决这种问题的。

活跃调用数越小，表明该服务提供者效率越高，单位时间内可处理更多的请求。此时应优先将请求分配给该服务提供者。在具体实现中，每个服务提供者对应一个活跃数。初始情况下，所有服务提供者活跃数均为0。每收到一个请求，活跃数加1，完成请求后则将活跃数减1。在服务运行一段时间后，性能好的服务提供者处理请求的速度更快，因此活跃数下降的也越快，此时这样的服务提供者能够优先获取到新的服务请求、这就是最小活跃数负载均衡算法的基本思想。除了最小活跃数，最小活跃数算法在实现上还引入了权重值。所以准确的来说，最小活跃数算法是基于加权最小活跃数算法实现的。举个例子说明一下，在一个服务提供者集群中，有两个性能优异的服务提供者。某一时刻它们的活跃数相同，则会根据它们的权重去分配请求，权重越大，获取到新请求的概率就越大。如果两个服务提供者权重相同，此时随机选择一个即可。

特点

加权最少活跃调用优先，活跃数越低，越优先调用，相同活跃数的进行加权随机。活跃数指调用前后计数差（针对特定提供者：请求发送数 - 响应返回数），表示特定提供者的任务堆积量，活跃数越低，代表该提供者处理能力越强。
使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大；相对的，处理能力越强的节点，处理更多的请求。

代码实现

因为活跃数是需要服务器请求处理相关逻辑配合的，一次调用开始时活跃数+1，结束是活跃数-1，所以这里就不对这部分逻辑进行模拟了，直接使用一个map来进行模拟。

public class LeastActive {
    private static String getServer() {
        //找出当前活跃数最小的服务器
        Optional<Integer> minValue = ServerIps.ACTIVITY_LIST.values().stream().min(Comparator.naturalOrder());

        if (minValue.isPresent()) {
            List<String> minActivityIps = new ArrayList<>();
            ServerIps.ACTIVITY_LIST.forEach((ip, activity) -> {
                if (activity.equals(minValue.get())) {
                    minActivityIps.add(ip);
                }
            });

            // 最小活跃数的ip有多个，则根据权重来选，权重大的优先
            if (minActivityIps.size() > 1) {
                Map<String, Integer> weightList = new LinkedHashMap<String, Integer>();

                ServerIps.WEIGHT_LIST.forEach((ip, weight) -> {
                    if (minActivityIps.contains(ip)) {
                        weightList.put(ip, ServerIps.WEIGHT_LIST.get(ip));
                    }
                });

                int totalWeight = 0;

                boolean sameWeight = true;//如果所有权重都相等，那么随机一个ip即可
                Object[] weights = weightList.values().toArray();
                for (int i = 0; i < weights.length; i++) {
                    Integer weight = (Integer) weights[i];
                    totalWeight += weight;

                    if (sameWeight && i > 0 && !weight.equals(weights[i - 1])) {
                        sameWeight = false;
                    }
                }
                Random random = new Random();
                int randomRos = random.nextInt(totalWeight);

                if (!sameWeight) {
                    for (String ip : weightList.keySet()) {
                        Integer value = weightList.get(ip);
                        if (randomRos < value) {
                            return ip;
                        }
                        randomRos = randomRos - value;
                    }
                }
                return (String) weightList.keySet().toArray()[new Random().nextInt(weightList.size())];
            } else {
                return minActivityIps.get(0);
            }
        } else {
            return (String) ServerIps.WEIGHT_LIST.keySet().toArray()[new Random().nextInt(ServerIps.WEIGHT_LIST.size())];
        }
    }

    public static void main(String[] args) {
        //连续调用10次，随机10个client
        for (int i = 0; i < 10; i++) {
            System.out.println(getServer());
        }
    }
}

Dubbo中负载均衡

如果在消费端和服务端都配置了负载均衡策略，以消费端为准。

最少活跃调用数

最少活跃数是在消费端进行统计的，统计有多少个请求正在执行中。

原理逻辑

消费者会缓存所调用服务的所有提供者，比如记为p1、p2、p3三个服务提供者，每个提供者内都有一个属性记为active，默认位0
消费者在调用次服务时，如果负载均衡策略是leastactive
消费者端会判断缓存的所有服务提供者的active,选择最小的，如果都相同，则随机
选出某一个服务提供者后，假设位p2，Dubbo就会对p2.active+1
然后真正发出请求调用该服务
消费端收到响应结果后，对p2.active-1
这样就完成了对某个服务提供者当前活跃调用数进行了统计，并且并不影响服务调用的性能

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：如何搭建rpc网关 rpc网络

下一篇：opencv图像保存mp4 opencv保存raw格式照片

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯