dubbo负载均衡-RandomLoadBalance

dubbo负载均衡-RandomLoadBalance

发表于 2019-10-13

前言

之前在面试中被问及dubbo的负载均衡，当时没有系统的回答出来，今天查阅了一下官方文档，于是出现了这篇文章。dubbo主要有4种负载均衡方式，分别是：基于权重随机算法的RandomLoadBalance、基于最少活跃调用数算法的LeastActiveLoadBalance、基于Hash一致性的ConsistentHashLoadBalance、以及基于加权轮询算法的RoundRobinLoadBalance。

源码分析

在 Dubbo 中，所有负载均衡实现类均继承自 AbstractLoadBalance，该类实现了 LoadBalance 接口，并封装了一些公共的逻辑。所以在分析负载均衡实现之前，先来看一下 AbstractLoadBalance 的逻辑。首先来看一下负载均衡的入口方法 select，如下：

\@Override  
public \<T> Invoker\<T> select\(List\<Invoker\<T>> invokers, URL url, Invocation invocation\) \{  
 if \(invokers == null |\| invokers.isEmpty\(\)\)  
 return null;  
 // 如果 invokers 列表中仅有一个 Invoker，直接返回即可，无需进行负载均衡  
 if \(invokers.size\(\) == 1\)  
 return invokers.get\(0\);  
    
 // 调用 doSelect 方法进行负载均衡，该方法为抽象方法，由子类实现  
 return doSelect\(invokers, url, invocation\);  
\}  
  
protected abstract \<T> Invoker\<T> doSelect\(List\<Invoker\<T>> invokers, URL url, Invocation invocation\);  

select主要对invokers进行了合法性的校验，而如果集合中只有一个invoker的话，就不需进行负载均衡了，直接返回就好；对于多个invoker则调用doSelect方法进行负载均衡选择出一个invoker，doSelect可被不同的负载均衡算法实现。

AbstractLoadBalance还封装了一些其他的公共逻辑，例如服务提供者权重计算逻辑。实现如下：

protected int getWeight\(Invoker\<\?> invoker, Invocation invocation\) \{  
 // 从 url 中获取权重 weight 配置值  
 int weight = invoker.getUrl\(\).getMethodParameter\(invocation.getMethodName\(\), Constants.WEIGHT\_KEY, Constants.DEFAULT\_WEIGHT\);  
 if \(weight > 0\) \{  
 // 获取服务提供者启动时间戳  
 long timestamp = invoker.getUrl\(\).getParameter\(Constants.REMOTE\_TIMESTAMP\_KEY, 0L\);  
 if \(timestamp > 0L\) \{  
 // 计算服务提供者运行时长  
 int uptime = \(int\) \(System.currentTimeMillis\(\) - timestamp\);  
 // 获取服务预热时间，默认为10分钟  
 int warmup = invoker.getUrl\(\).getParameter\(Constants.WARMUP\_KEY, Constants.DEFAULT\_WARMUP\);  
 // 如果服务运行时间小于预热时间，则重新计算服务权重，即降权  
 if \(uptime > 0 \&\& uptime \< warmup\) \{  
 // 重新计算服务权重  
 weight = calculateWarmupWeight\(uptime, warmup, weight\);  
 \}  
 \}  
 \}  
 return weight;  
\}  
  
static int calculateWarmupWeight\(int uptime, int warmup, int weight\) \{  
 // 计算权重，下面代码逻辑上形似于 \(uptime / warmup\) \* weight。  
 // 随着服务运行时间 uptime 增大，权重计算值 ww 会慢慢接近配置值 weight，并最终大于 weight  
 int ww = \(int\) \(\(float\) uptime / \(\(float\) warmup / \(float\) weight\)\);  
 //预热结束后最终返回weight的值  
 return ww \< 1 \? 1 : \(ww > weight \? weight : ww\);  
\}  

上面是权重的计算过程，该过程主要用于保证当服务运行时长小于服务预热时间时，对服务进行降权，避免让服务在启动之初就处于高负载状态。

关于 AbstractLoadBalance 就先分析到这，接下来分析各个实现类的代码。首先，我们从 Dubbo 缺省的实现类 RandomLoadBalance 看起。

1. RandomLoadBalance

RandomLoadBalance 是加权随机算法的具体实现，它的算法思想很简单。假设我们有一组服务器 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次。

以上就是 RandomLoadBalance 背后的算法思想，比较简单。下面开始分析源码。

public class RandomLoadBalance extends AbstractLoadBalance \{  
  
 public static final String NAME = "random";  
  
 private final Random random = new Random\(\);  
  
 \@Override  
 protected \<T> Invoker\<T> doSelect\(List\<Invoker\<T>> invokers, URL url, Invocation invocation\) \{  
 int length = invokers.size\(\);  
 int totalWeight = 0;  
 boolean sameWeight = true;  
 // 下面这个循环有两个作用，第一是计算总权重 totalWeight，  
 // 第二是检测每个服务提供者的权重是否相同  
 for \(int i = 0; i \< length; i++\) \{  
 int weight = getWeight\(invokers.get\(i\), invocation\);  
 // 累加权重  
 totalWeight += weight;  
 // 检测当前服务提供者的权重与上一个服务提供者的权重是否相同，  
 // 不相同的话，则将 sameWeight 置为 false。  
 if \(sameWeight \&\& i > 0  
 \&\& weight \!= getWeight\(invokers.get\(i - 1\), invocation\)\) \{  
 sameWeight = false;  
 \}  
 \}  
    
 // 下面的 if 分支主要用于获取随机数，并计算随机数落在哪个区间上  
 if \(totalWeight > 0 \&\& \!sameWeight\) \{  
 // 随机获取一个 \[0, totalWeight\) 区间内的数字  
 int offset = random.nextInt\(totalWeight\);  
 // 循环让 offset 数减去服务提供者权重值，当 offset 小于0时，返回相应的 Invoker。  
 // 举例说明一下，我们有 servers = \[A, B, C\]，weights = \[5, 3, 2\]，offset = 7。  
 // 第一次循环，offset - 5 = 2 > 0，即 offset > 5，  
 // 表明其不会落在服务器 A 对应的区间上。  
 // 第二次循环，offset - 3 = -1 \< 0，即 5 \< offset \< 8，  
 // 表明其会落在服务器 B 对应的区间上  
 for \(int i = 0; i \< length; i++\) \{  
 // 让随机值 offset 减去权重值  
 offset -= getWeight\(invokers.get\(i\), invocation\);  
 if \(offset \< 0\) \{  
 // 返回相应的 Invoker  
 return invokers.get\(i\);  
 \}  
 \}  
 \}  
    
 // 如果所有服务提供者权重值相同，此时直接随机返回一个即可  
 return invokers.get\(random.nextInt\(length\)\);  
 \}  
\}  

RandomLoadBalance 的算法思想比较简单，在经过多次请求后，能够将调用请求按照权重值进行“均匀”分配。当然 RandomLoadBalance 也存在一定的缺点，当调用次数比较少时，Random 产生的随机数可能会比较集中，此时多数请求会落到同一台服务器上。这个缺点并不是很严重，多数情况下可以忽略。RandomLoadBalance 是一个简单，高效的负载均衡实现，因此 Dubbo 选择它作为缺省实现。

关于 RandomLoadBalance 就先到这了，下一篇我们继续分析 LeastActiveLoadBalance。

[\# dubbo](/tags/dubbo/) [\# 负载均衡](/tags/负载均衡/)

[阿里云OSS工具类](/2019/09/15/阿里云OSS工具类/ "阿里云OSS工具类")

[dubbo负载均衡-LeastActiveLoadBalance](/2019/10/26/dubbo负载均衡-LeastActiveLoadBalance/ "dubbo负载均衡-LeastActiveLoadBalance")