【图文并茂】一文讲透Dubbo负载均衡之最小活跃数算法 (看源码思路)
精尽 Dubbo 源码解析 —— 集群容错（四）之 LoadBalance 实现
随机权重
基本逻辑、代码解析
随机，按权重设置随机概率。
在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重（监控界面可以倍权、半权）。
1、获取每个Invoker的权重（权重预热），及总权重
2、如果每个权重相等，随机选择Invoker
3、根据总权重，生成一个随机int值，看看落在哪个权重区间。
@Override protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) { int length = invokers.size(); // Number of invokers int totalWeight = 0; // The sum of weights boolean sameWeight = true; // Every invoker has the same weight? // 计算总权限 for (int i = 0; i < length; i++) { int weight = getWeight(invokers.get(i), invocation); // 获得权重 totalWeight += weight; // Sum if (sameWeight && i > 0 && weight != getWeight(invokers.get(i - 1), invocation)) { sameWeight = false; } } // 权重不相等，随机后，判断在哪个 Invoker 的权重区间中 if (totalWeight > 0 && !sameWeight) { // 随机 // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight. int offset = random.nextInt(totalWeight); // Return a invoker based on the random value. // 区间判断 for (Invoker<T> invoker : invokers) { offset -= getWeight(invoker, invocation); if (offset < 0) { return invoker; } } } // 权重相等，平均随机 // If all invokers have the same weight value or totalWeight=0, return evenly. return invokers.get(random.nextInt(length)); }
举例
假定有3台dubbo provider:
10.0.0.1:20884, weight=2
10.0.0.1:20886, weight=3
10.0.0.1:20888, weight=4
随机算法的实现：
totalWeight=9;
假设offset=1（即random.nextInt(9)=1）
1-2=-1<0？是，所以选中 10.0.0.1:20884, weight=2
假设offset=4（即random.nextInt(9)=4）
4-2=2<0？否，这时候offset=2， 2-3<0？是，所以选中 10.0.0.1:20886, weight=3
假设offset=7（即random.nextInt(9)=7）
7-2=5<0？否，这时候offset=5， 5-3=2<0？否，这时候offset=2， 2-4<0？是，所以选中 10.0.0.1:20888, weight=4
轮询权重
基本逻辑、代码解析
轮循，按公约后的权重设置轮循比率。
存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。
当这个机器的权重很低，其实也不会很多请求到此机器。
1、每个service+method，作为key，保存请求的序号。
2、如果权重（预热权重）相等，每个invoker依次处理请求。
3、不等的话，按权重承担请求份额。
/** * 服务方法与计数器的映射 * * KEY：serviceKey + "." + methodName */ private final ConcurrentMap<String, AtomicPositiveInteger> sequences = new ConcurrentHashMap<String, AtomicPositiveInteger>(); @Override 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(); // Number of invokers int maxWeight = 0; // The maximum weight int minWeight = Integer.MAX_VALUE; // The minimum weight 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); // Choose the maximum weight minWeight = Math.min(minWeight, weight); // Choose the minimum weight if (weight > 0) { invokerToWeightMap.put(invokers.get(i), new IntegerWrapper(weight)); weightSum += weight; } } // 获得 AtomicPositiveInteger 对象 AtomicPositiveInteger sequence = sequences.get(key); if (sequence == null) { sequences.putIfAbsent(key, new AtomicPositiveInteger()); sequence = sequences.get(key); } // 获得当前顺序号，并递增 + 1 int currentSequence = sequence.getAndIncrement(); // 权重不相等，顺序根据权重分配 if (maxWeight > 0 && minWeight < maxWeight) { int mod = currentSequence % weightSum; // 剩余权重 for (int i = 0; i < maxWeight; i++) { // 循环最大权重 for (Map.Entry<Invoker<T>, IntegerWrapper> each : invokerToWeightMap.entrySet()) { // 循环 Invoker 集合 final Invoker<T> k = each.getKey(); final IntegerWrapper v = each.getValue(); // 剩余权重归 0 ，当前 Invoker 还有剩余权重，返回该 Invoker 对象 if (mod == 0 && v.getValue() > 0) { return k; } // 若 Invoker 还有权重值，扣除它( value )和剩余权重( mod )。 if (v.getValue() > 0) { v.decrement(); mod--; } } } } // 权重相等，平均顺序获得 // Round robin return invokers.get(currentSequence % length); }
举例
1、假定有3台权重都一样的dubbo provider:
10.0.0.1:20884, weight=100
10.0.0.1:20886, weight=100
10.0.0.1:20888, weight=100
轮询算法的实现：
其调用方法某个方法(key)的 sequence 从 0 开始：
sequence=0时，选择invokers.get(0%3)=10.0.0.1:20884
sequence=1时，选择invokers.get(1%3)=10.0.0.1:20886
sequence=2时，选择invokers.get(2%3)=10.0.0.1:20888
sequence=3时，选择invokers.get(3%3)=10.0.0.1:20884
sequence=4时，选择invokers.get(4%3)=10.0.0.1:20886
sequence=5时，选择invokers.get(5%3)=10.0.0.1:20888
2、当3台权重不一样的dubbo provider:
10.0.0.1:20884, weight=1 机器1
10.0.0.1:20886, weight=2 机器2
10.0.0.1:20888, weight=4 机器3
轮询算法的实现：
其调用方法某个方法(key)的 sequence 从 0 开始：
sequence=0时，选择机器1
sequence=1时，选择机器2
sequence=2时，选择机器3
sequence=3时，选择机器2
sequence=4时，选择机器3
sequence=5时，选择机器3
sequence=6时，选择机器3
即：轮询各个invoker的相对权重，再轮询。
最小活跃度
基本逻辑、代码解析
最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
相比来说，LeastActiveLoadBalance 是 RandomLoadBalance 的加强版，基于最少活跃调用数。
每次真正调用前，活跃度+1，调用完成，活跃度-1。所以，活跃度越小，说明处理越快，可以承担更多的请求量。
1、遍历 invokers 列表，寻找活跃数最小的 Invoker
2、如果有多个 Invoker 具有相同的最小活跃数，此时记录下这些 Invoker 在 invokers 集合中的下标，并累加它们的权重，比较它们的权重值是否相等
3、如果只有一个 Invoker 具有最小的活跃数，此时直接返回该 Invoker 即可
4、如果有多个 Invoker 具有最小活跃数，且它们的权重（预热权重）不相等，此时处理方式和 RandomLoadBalance 一致
5、如果有多个 Invoker 具有最小活跃数，但它们的权重相等，此时随机返回一个即可
所以我觉得最小活跃数负载均衡的全称应该叫做：有最小活跃数用最小活跃数，没有最小活跃数根据权重选择，权重一样则随机返回的负载均衡算法。
@Override protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) { int length = invokers.size(); // 总个数 int leastActive = -1; // 最小的活跃数 int leastCount = 0; // 相同最小活跃数的个数 int[] leastIndexes = new int[length]; // 相同最小活跃数的下标 int totalWeight = 0; // 总权重 int firstWeight = 0; // 第一个权重，用于于计算是否相同 boolean sameWeight = true; // 是否所有权重相同 // 计算获得相同最小活跃数的数组和个数 for (int i = 0; i < length; i++) { Invoker<T> invoker = invokers.get(i); int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // 活跃数 int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // 权重 if (leastActive == -1 || active < leastActive) { // 发现更小的活跃数，重新开始 leastActive = active; // 记录最小活跃数 leastCount = 1; // 重新统计相同最小活跃数的个数 leastIndexes[0] = i; // 重新记录最小活跃数下标 totalWeight = weight; // 重新累计总权重 firstWeight = weight; // 记录第一个权重 sameWeight = true; // 还原权重相同标识 } else if (active == leastActive) { // 累计相同最小的活跃数 leastIndexes[leastCount++] = i; // 累计相同最小活跃数下标 totalWeight += weight; // 累计总权重 // 判断所有权重是否一样 if (sameWeight && weight != firstWeight) { sameWeight = false; } } } // assert(leastCount > 0) if (leastCount == 1) { // 如果只有一个最小则直接返回 return invokers.get(leastIndexes[0]); } if (!sameWeight && totalWeight > 0) { // 如果权重不相同且权重大于0则按总权重数随机 int offsetWeight = random.nextInt(totalWeight); // 并确定随机值落在哪个片断上 for (int i = 0; i < leastCount; i++) { int leastIndex = leastIndexes[i]; offsetWeight -= getWeight(invokers.get(leastIndex), invocation); if (offsetWeight <= 0) { return invokers.get(leastIndex); } } } // 如果权重相同或权重为0则均等随机 return invokers.get(leastIndexes[random.nextInt(leastCount)]); }
举例
假定有3台dubbo provider:
10.0.0.1:20884, weight=2，active=2
10.0.0.1:20886, weight=3，active=4
10.0.0.1:20888, weight=4，active=3
active=2最小，且只有一个2，所以选择10.0.0.1:20884
假定有3台dubbo provider:
10.0.0.1:20884, weight=2，active=2
10.0.0.1:20886, weight=3，active=2
10.0.0.1:20888, weight=4，active=3
active=2最小，且有2个，所以从[10.0.0.1:20884,10.0.0.1:20886 ]中选择；
接下来的算法与随机算法类似：
假设offset=1（即random.nextInt(5)=1）
1-2=-1<0？是，所以选中 10.0.0.1:20884, weight=2
假设offset=4（即random.nextInt(5)=4）
4-2=2<0？否，这时候offset=2， 2-3<0？是，所以选中 10.0.0.1:20886, weight=3
一致性hash
基本逻辑、代码解析
一致性 Hash，相同参数的请求总是发到同一提供者。
当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点（默认160个），平摊到其它提供者，不会引起剧烈变动。
/** * 服务方法与一致性哈希选择器的映射 * * KEY：serviceKey + "." + methodName */ private final ConcurrentMap<String, ConsistentHashSelector<?>> selectors = new ConcurrentHashMap<String, ConsistentHashSelector<?>>(); @SuppressWarnings("unchecked") @Override protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) { String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName(); // 基于 invokers 集合，根据对象内存地址来计算定义哈希值 int identityHashCode = System.identityHashCode(invokers); // 获得 ConsistentHashSelector 对象。若为空，或者定义哈希值变更（说明 invokers 集合发生变化），进行创建新的 ConsistentHashSelector 对象 ConsistentHashSelector<T> selector = (ConsistentHashSelector<T>) selectors.get(key); if (selector == null || selector.identityHashCode != identityHashCode) { selectors.put(key, new ConsistentHashSelector<T>(invokers, invocation.getMethodName(), identityHashCode)); selector = (ConsistentHashSelector<T>) selectors.get(key); } return selector.select(invocation); } private static final class ConsistentHashSelector<T> { /** * 虚拟节点与 Invoker 的映射关系 */ private final TreeMap<Long, Invoker<T>> virtualInvokers; /** * 每个Invoker 对应的虚拟节点数 */ private final int replicaNumber; /** * 定义哈希值 */ private final int identityHashCode; /** * 取值参数位置数组 */ private final int[] argumentIndex; ConsistentHashSelector(List<Invoker<T>> invokers, String methodName, int identityHashCode) { this.virtualInvokers = new TreeMap<Long, Invoker<T>>(); // 设置 identityHashCode this.identityHashCode = identityHashCode; URL url = invokers.get(0).getUrl(); // 初始化 replicaNumber this.replicaNumber = url.getMethodParameter(methodName, "hash.nodes", 160); // 初始化 argumentIndex String[] index = Constants.COMMA_SPLIT_PATTERN.split(url.getMethodParameter(methodName, "hash.arguments", "0")); argumentIndex = new int[index.length]; for (int i = 0; i < index.length; i++) { argumentIndex[i] = Integer.parseInt(index[i]); } // 初始化 virtualInvokers for (Invoker<T> invoker : invokers) { String address = invoker.getUrl().getAddress(); // 每四个虚拟结点为一组，为什么这样？下面会说到 for (int i = 0; i < replicaNumber / 4; i++) { // 这组虚拟结点得到惟一名称 byte[] digest = md5(address + i); // Md5是一个16字节长度的数组，将16字节的数组每四个字节一组，分别对应一个虚拟结点，这就是为什么上面把虚拟结点四个划分一组的原因 for (int h = 0; h < 4; h++) { // 对于每四个字节，组成一个long值数值，做为这个虚拟节点的在环中的惟一key long m = hash(digest, h); virtualInvokers.put(m, invoker); } } } } public Invoker<T> select(Invocation invocation) { // 基于方法参数，获得 KEY String key = toKey(invocation.getArguments()); // 计算 MD5 值 byte[] digest = md5(key); // 计算 KEY 值 return selectForKey(hash(digest, 0)); } private String toKey(Object[] args) { StringBuilder buf = new StringBuilder(); for (int i : argumentIndex) { if (i >= 0 && i < args.length) { buf.append(args[i]); } } return buf.toString(); } private Invoker<T> selectForKey(long hash) { // 得到大于当前 key 的那个子 Map ，然后从中取出第一个 key ，就是大于且离它最近的那个 key Map.Entry<Long, Invoker<T>> entry = virtualInvokers.tailMap(hash, true).firstEntry(); // 不存在，则取 virtualInvokers 第一个 if (entry == null) { entry = virtualInvokers.firstEntry(); } // 存在，则返回 return entry.getValue(); } private long hash(byte[] digest, int number) { return (((long) (digest[3 + number * 4] & 0xFF) << 24) | ((long) (digest[2 + number * 4] & 0xFF) << 16) | ((long) (digest[1 + number * 4] & 0xFF) << 8) | (digest[number * 4] & 0xFF)) & 0xFFFFFFFFL; } // 计算 MD5 private byte[] md5(String value) { MessageDigest md5; try { md5 = MessageDigest.getInstance("MD5"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e.getMessage(), e); } md5.reset(); byte[] bytes; try { bytes = value.getBytes("UTF-8"); } catch (UnsupportedEncodingException e) { throw new IllegalStateException(e.getMessage(), e); } md5.update(bytes); return md5.digest(); } }