Dubbo-负载均衡原理解析，卑微打工人

于 2024-04-01 08:55:26 发布
阅读量852 收藏 23
点赞数 22
分类专栏： 2024年程序员学习 文章标签： dubbo 负载均衡 windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asnmd1283/article/details/137217867
版权

特点

  • 加权随机，按权重设置随机概率。

  • 在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

  • 缺点：存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

代码实现

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 ips = new ArrayList();

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;

  1. offset<5 is false，所以不在[0, 5)区间，将offset = offset - 5（offset=2）

  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号调用，1%8=1；

  2. 2号调用，2%8=2；

  3. 3号调用，3%8=3；

  4. 8号调用，8%8=0；

  5. 9号调用，9%8=1；

  6. 100号调用，100%8=4；

我们发现调用编号可以被缩小为0-7之间的8个数字，问题是怎么根据这个8个数字找到对应的服务器呢？和我们随机算法类似，这里也可以把权重想象为一个坐标轴“0-----2-----7-----8”

  1. 1号调用，1%8=1，offset = 1, offset <= 2 is true，取A；

  2. 2号调用，2%8=2；offset = 2，offset <= 2 is true, 取A;

  3. 3号调用，3%8=3；offset = 3, offset <= 2 is false, offset = offset - 2, offset = 1, offset <= 5，取B

  4. 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;

  5. 9号调用，9%8=1；// …

  6. 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);

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
img
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
img

总结

如果你选择了IT行业并坚定的走下去，这个方向肯定是没有一丝问题的，这是个高薪行业，但是高薪是凭自己的努力学习获取来的，这次我把P8大佬用过的一些学习笔记（pdf）都整理在本文中了

《Java中高级核心知识全面解析》

小米商场项目实战，别再担心面试没有实战项目：

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-DIMVDDet-1711932914974)]
[外链图片转存中…(img-ZXQ8iDPG-1711932914976)]
[外链图片转存中…(img-qZCINg3h-1711932914977)]
[外链图片转存中…(img-tvpRgK3k-1711932914978)]
[外链图片转存中…(img-puScemvs-1711932914979)]
[外链图片转存中…(img-zmX9iy0j-1711932914980)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-CcIImqlc-1711932914982)]

总结

如果你选择了IT行业并坚定的走下去，这个方向肯定是没有一丝问题的，这是个高薪行业，但是高薪是凭自己的努力学习获取来的，这次我把P8大佬用过的一些学习笔记（pdf）都整理在本文中了

《Java中高级核心知识全面解析》

[外链图片转存中…(img-1rAh1IKY-1711932914983)]

小米商场项目实战，别再担心面试没有实战项目：

[外链图片转存中…(img-tHpDYtaB-1711932914983)]

asnmd1283
关注
专栏目录
5种Dubbo负载均衡算法（看这一篇就够了）
gongsenlin341的博客
03-16 4062
文章目录1.概述2.随机+权重（random）3.轮询+权重（roundrobin）4.最少连接（leastactive）5.最短响应（shortestresponse）6.一致性哈希（consistenthash） 1.概述 ​ 2.7.9版本的Dubbo官方提供的负载均衡算法有5种，在2.6.*里面只有4种负载均衡算法。本文将详细的介绍这5种算法的底层实现。 2.随机+权重（random） 算法步骤 计算服务提供者的总权重，并维护一个前缀和数组。 基于第一步的结果，在0～总权重之间生成一个随机数。
DUBBO负载均衡算法及源码分析
sinat_22143835的博客
05-28 606
文章目录DUBBO负载均衡算法及源码分析前言类结构随机权重-RandomLoadBalance算法思想源码分析主要代码-doSelectgetweight分析加权轮询-RoundRobinLoadBalance算法思想步骤分析源码分析最少活跃连接数-LeastActiveLoadBalance算法思想源码分析一致性hash-ConsistentHashLoadBalance算法思想源码分析补充总结 DUBBO负载均衡算法及源码分析 前言 ​ 下面是dubbo官方集群容错的布局图，集群容错有以下组件，
Dubbo 负载均衡算法说明
最新发布
O(∩_∩)O哈哈~
03-28 844
在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为基于权重的随机负载均衡策略。具体实现上，Dubbo 提供的是客户端负载均衡，即由 Consumer 通过负载均衡算法得出需要将请求提交到哪个 Provider 实例。目前 Dubbo 内置了如下负载均衡算法，可通过调整配置项启用。
Dubbo实现负载均衡原理
summer07071126的博客
09-13 457
一个杭州的服务消费方发起了一次调用，然后发生了以下的事情: 根据配置的路由规则，如果杭州发起的调用，会路由到比较近的上海的20个 Provider。上面的第1，2，4步骤就分别对应了路由，负载均衡和集群容错。所以，事实上，到最终客户端决定使用哪个负载均衡策略时，只是从请求参数中取出 loadbalance=xxx 的参数，进而决定具体实例。注意: 虽说以上配置有全封闭服务端配置的，有针对客户端配置的，但是，真正使负载均衡起作用的是，客户端在发起调用的时候，使用相应负载均衡算法进行选择调用。
dubbo的四种负载均衡算法
weixin_40852944的博客
04-18 248
ConsistentHashLoadBalance（一致性哈希负载均衡） LeastActiveLoadBalance RandomLoadBalance RoundRobinLoadBalance
Dubbo-负载均衡算法.docx
07-28
### Dubbo中的负载均衡算法详解 #### 一、概述 在分布式系统中，负载均衡是一项关键技术，用于提高系统的可用性和扩展性。Dubbo作为一个广泛使用的微服务框架，提供了多种负载均衡策略来支持服务间的调用分发。这些...
jmeter-plugins-dubbo-2.7.1-jar-with-dependencies
06-08
本文将深入探讨“jmeter-plugins-dubbo-2.7.1-jar-with-dependencies”这一系统压测工具包，它专门针对基于Java的Dubbo服务进行性能测试。了解并熟练掌握这一工具，能帮助我们更好地优化服务性能，提升系统的稳定性...
incubator-dubbo-dubbo-2.6.1
04-26
【标题】"incubator-dubbo-dubbo-2.6.1" 是一个Apache Incubator项目Dubbo的特定版本，这里的2.6.1表示该版本是Dubbo的稳定分支之一。 【描述】提到的"incubator-dubbo-dubbo-2.6.1"表明这是Apache孵化器中的Dubbo...
dubbo-admin-2.5.4.war
08-22
【标题】"dubbo-admin-2.5.4.war" 指的是 Dubbo 提供的一款基于 Web 的管理控制台应用，版本为 2.5.4。这个 WAR 文件是一种打包好的 Java Web 应用程序，可以在支持 Java Servlet 的容器（如 Apache Tomcat）上部署...
dubbo-admin
01-25
【标题】"dubbo-admin" 是一款基于 Dubbo 框架开发的管理控制台，主要用于监控和服务治理。Dubbo 是阿里巴巴开源的一款高性能、轻量级的服务治理框架，它提供了服务注册、服务发现、调用跟踪、性能统计等一系列功能...
简单认识dubbo中的几种负载均衡算法
qq_22610595的博客
11-12 1335
负载均衡在微服务层次主要解决的是服务器压力的问题，通过负载均衡算法可以将请求分摊到不同的微服务上，从而解决某台微服务因请求压力过大导致服务奔溃现象。本文就dubbo中的几种负载均衡算法进行分析，通过了解dubbo中负载均衡算法的实现，从而熟悉负载均衡算法的核心思想。
Dubbo-负载均衡原理解析
张姐姐聊编程
12-29 961
我们的程序是分布式应用，服务部署在几个节点（服务器）上，当消费者调用服务时，zk返回给dubbo的是一个节点列表，但是dubbo只会选择一台服务器，那么它究竟会选择哪一台呢？这就是dubbo的负载均衡策略了，本篇博客就来聚焦dubbo的负载均衡策略。
dubbo负载算法之加权轮询算法
恨_别离的博客
10-26 680
轮询是一种无状态负载均衡算法，实现简单，适用于每台服务器性能相近的场景下。但现实情况下，我们并不能保证每台服务器性能均相近。如果我们将等量的请求分配给性能较差的服务器，这显然是不合理的。因此，这个时候我们需要对轮询过程进行加权，以调控每台服务器的负载。经过加权后，每台服务器能够得到的请求数比例，接近或等于他们的权重比。比如服务器 A、B、C 权重比为 5:2:1。那么在8次请求中，服务器 A 将收到其中的5次请求，服务器 B 会收到其中的2次请求，服务器 C 则收到其中的1次请求。以上就是加权轮询的算法思想
dubbo中的负载均衡算法
wenlai123456的博客
09-07 124
例如 ABC 三节点有如下权重：{A: 3, B: 2, C: 1} 那么按照最原始的轮询算法，调用过程将变成：A A A B B C。我们发现经过合计权重（3+2+1）轮次后，循环又回到了起点，整个过程中节点流量是平滑的，且哪怕在很短的时间周期内，概率都是按期望分布的。然后生成区间[0,5),[5,8),[8,10],随机范围为0~10，权重越大则概率越大。根据目标集群服务器，处理性能最高的权重越高，处理性能较低的，权重也交低。则按照 A,,A,A,A,A,B,B,B,C,C轮询。
Dubbo支持几种负载均衡策略
2301_78102191的博客
05-22 1496
存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在 那，久而久之，所有请求都卡在调到第二台。存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第。器，获取每个服务的权重，然后累加权重值，判断每个服务的提供者权重是否相同，如果每个调用者的权重不相同，并且每个权重大于。另外，如果每个机器的权重的都相同，那么权重就不会参与计算，直接选择随机算法生成的某一个选择，完。当请求多了的话，就要考虑各服务器的负载，一共。
Dubbo负载均衡策略
青山师
04-07 2700
在Dubbo中，负载均衡是实现高可用和高性能的重要手段之一。Dubbo支持多种负载均衡策略，可以根据业务场景进行选择。本文将详细介绍Dubbo支持的负载均衡策略，并结合代码实践给出操作步骤。
Dubbo源码解析之加权轮询策略RoundRobinLoadBalance
进击的小白
11-21 1493
package org.apache.dubbo.rpc.cluster.loadbalance; import org.apache.dubbo.common.URL; import org.apache.dubbo.rpc.Invocation; import org.apache.dubbo.rpc.Invoker; import java.util.Collection; import java.util.List; import java.util.Map; import java.util.
Dubbo中的负载均衡算法之平滑加权轮询算法源码解析
阿星的博客
11-13 819
深入dubbo源码介绍平滑加权轮询算法的设计和实现
平滑加权轮询算法
大张
03-19 3844
平滑加权轮询算法 简介 我们在使用nginx或者rpc框架的时候，经常会用到负载均衡策略。负载均衡策略中有一致性hash、权重算法、轮询、最小活跃输、随机等。 今天采用通俗易懂的白话讲解一下为何nginx、dubbo采用的平滑加权轮询算法？ 它和我们平时使用的权重算法到底有何区别呢？ 实现 一般的权重算法 我们有三个节点A，B，C,假设权重分配为3，1，1； 那么如果在做rpc调用的时候，进来了5个请求；那么如果按照权重分配比，处理请求节点的情况是 AAABCAAABC。具体实现我们可.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值