dubbo的輪詢機制說明
阿新 • • 發佈：2019-02-02
針對dubbo的文章已經很多，
我們這裡通過程式碼的解析，簡單描述下各種負載均衡的實現方式
隨機負載均衡（RandomLoadBalance）：先統計所有伺服器上該介面方法的權重總和，然後對這個總和隨機nextInt一下，看生成的隨機數落到哪個段內，就調哪個伺服器上的該服務。
輪詢負載均衡（RoundRobinLoadBalance）：如果所有伺服器的該介面方法的權重一樣，則直接內部的序列計數器（sequences）+1然後對伺服器的數量進行取模來決定呼叫哪個伺服器上的服務；如果伺服器的該介面方法的權重不一樣（就是說存在預熱中的伺服器），則找到其中最大的權重，然後將內部的權重計數器（weightSequences）+1並對該最大權重數取模，然後再找出權重比該取模後的值大伺服器列表，最後通過內部的序列計數器（sequences）+1然後對伺服器列表數量進行取模來決定呼叫哪個伺服器上的服務。protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) { int length = invokers.size(); // 總個數 int totalWeight = 0; // 總權重 boolean sameWeight = true; // 權重是否都一樣 for (int i = 0; i < length; i++) { int weight = getWeight(invokers.get(i), invocation); totalWeight += weight; // 累計總權重 if (sameWeight && i > 0 && weight != getWeight(invokers.get(i - 1), invocation)) { sameWeight = false; // 計算所有權重是否一樣 } } if (totalWeight > 0 && ! sameWeight) { // 如果權重不相同且權重大於0則按總權重數隨機 int offset = random.nextInt(totalWeight); // 並確定隨機值落在哪個片斷上 for (int i = 0; i < length; i++) { offset -= getWeight(invokers.get(i), invocation); if (offset < 0) { return invokers.get(i); } } } // 如果權重相同或權重為0則均等隨機 return invokers.get(random.nextInt(length)); }
最少活躍負載均衡（LeastActiveLoadBalance）：每個介面和介面方法都對應一個RpcStatus物件，記錄了他們的活躍數、失敗數等等相關統計資訊，此種負載均衡方式是在活躍數最低的伺服器中對其權重的總和取模來看結果是在哪個權重段中，則選擇該伺服器來呼叫，活躍數就像併發量降級中的計數器一樣，開始呼叫時活躍數+1，呼叫結束時活躍數-1，所以活躍值越大，表明該提供者伺服器的該介面方法耗時越長，而消費能力強的提供者介面往往活躍值很低。最少活躍負載均衡保證了“慢”提供者能接收到更少的伺服器呼叫。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(); // 總個數 int maxWeight = 0; // 最大權重 int minWeight = Integer.MAX_VALUE; // 最小權重 for (int i = 0; i < length; i++) { int weight = getWeight(invokers.get(i), invocation); maxWeight = Math.max(maxWeight, weight); // 累計最大權重 minWeight = Math.min(minWeight, weight); // 累計最小權重 } if (maxWeight > 0 && minWeight < maxWeight) { // 權重不一樣 AtomicPositiveInteger weightSequence = weightSequences.get(key); if (weightSequence == null) { weightSequences.putIfAbsent(key, new AtomicPositiveInteger()); weightSequence = weightSequences.get(key); } int currentWeight = weightSequence.getAndIncrement() % maxWeight; List<Invoker<T>> weightInvokers = new ArrayList<Invoker<T>>(); for (Invoker<T> invoker : invokers) { // 篩選權重大於當前權重基數的Invoker if (getWeight(invoker, invocation) > currentWeight) { weightInvokers.add(invoker); } } int weightLength = weightInvokers.size(); if (weightLength == 1) { return weightInvokers.get(0); } else if (weightLength > 1) { invokers = weightInvokers; length = invokers.size(); } } AtomicPositiveInteger sequence = sequences.get(key); if (sequence == null) { sequences.putIfAbsent(key, new AtomicPositiveInteger()); sequence = sequences.get(key); } // 取模輪循 return invokers.get(sequence.getAndIncrement() % length); }
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) { int length = invokers.size(); // 總個數 int leastActive = -1; // 最小的活躍數 int leastCount = 0; // 相同最小活躍數的個數 int[] leastIndexs = 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; // 重新統計相同最小活躍數的個數 leastIndexs[0] = i; // 重新記錄最小活躍數下標 totalWeight = weight; // 重新累計總權重 firstWeight = weight; // 記錄第一個權重 sameWeight = true; // 還原權重相同標識 } else if (active == leastActive) { // 累計相同最小的活躍數 leastIndexs[leastCount ++] = i; // 累計相同最小活躍數下標 totalWeight += weight; // 累計總權重 // 判斷所有權重是否一樣 if (sameWeight && i > 0 && weight != firstWeight) { sameWeight = false; } } } // assert(leastCount > 0) if (leastCount == 1) { // 如果只有一個最小則直接返回 return invokers.get(leastIndexs[0]); } if (! sameWeight && totalWeight > 0) { // 如果權重不相同且權重大於0則按總權重數隨機 int offsetWeight = random.nextInt(totalWeight); // 並確定隨機值落在哪個片斷上 for (int i = 0; i < leastCount; i++) { int leastIndex = leastIndexs[i]; offsetWeight -= getWeight(invokers.get(leastIndex), invocation); if (offsetWeight <= 0) return invokers.get(leastIndex); } } // 如果權重相同或權重為0則均等隨機 return invokers.get(leastIndexs[random.nextInt(leastCount)]); }
一致雜湊負載均衡（ConsistentHashLoadBalance）：一致性雜湊演算法的負載均衡保證了同樣的請求（引數）將會落到同一臺伺服器上，這在某些場景是非常有用的，Dubbo中預設採用了160個虛擬節點，因為Dubbo的請求URL中除了我們使用的引數，還有些額外的系統呼叫引數，比如timestamp、loadbalance、pid和application等，有人可定會問，Dubbo會對URL中哪些引數進行hash，Dubbo預設除了對我們介面所有引數進行hash外，還會加上這些額外引數
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
int identityHashCode = System.identityHashCode(invokers);
ConsistentHashSelector<T> selector = (ConsistentHashSelector<T>) selectors.get(key);
if (selector == null || selector.getIdentityHashCode() != identityHashCode) {
selectors.put(key, new ConsistentHashSelector<T>(invokers, invocation.getMethodName(), identityHashCode));
selector = (ConsistentHashSelector<T>) selectors.get(key);
}
return selector.select(invocation);
}