自适应负载均衡（Dubbo）
一、Dubbo框架模型
说明：
- dubbo中有消费者Consumer,服务提供者Provider,注册中心Registry,以及RPC调用和监控中心。
- Consumer、Provider将URL信息以字符串的方式存储在注册中心，注册中心采用发布/订阅模式。
- Consumer、Provider与注册中心采用单一长连接，使用心跳模式，Provider的变更（宕机，变更资源信息）会及时通过发布/订阅模式通知到订阅者。
- Consumer寻找服务的过程称为服务发现，Provider注册URL到注册中心的过程为服务注册，Consumer通过RPC调用服务的过程为服务调用。
二、负载均衡定位
负载均衡功能：Consumer通过服务发现从注册中心拉取服务列表（Dubbo消费端将服务封装Invoker对象），Consumer在RPC调用服务之前，通过负载均衡从服务列表中选择一台服务器。
三、负载均衡接口
说明：dubbo提供负载均衡接口LoadBalance,开发者需要实现该接口，完成自己设计的select方法。
invokers：服务列表
invocation：Consumer调用服务器的传输的参数，方法名，封装在Invocatin对象中
在集群负载均衡时，Dubbo 提供了多种均衡策略，缺省为 random 随机调用。一般有选择算法 随机算法，哈希算法，加权算法，最小连接数算法。
各个算法流程图：
- 随机算法：如果各台服务器权重一样，使用随机算法选择一台服务器；否则，按照权重比率选择服务器。适应于服务器参数一致场景。
- 一致性哈希算法：相同参数的请求总是发到同一提供者，当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。缺省用 160 份虚拟节点。适应于服务器参数一致场景。
- 加权轮询算法：如果各台服务器权重一致，按照轮询选择服务器，否则，按照权重加权选择。适应于服务器参数不一致场景。
- 最小连接数算法：获取各台服务的活跃数（未处理的请求数），如果都不相等，选择最小活跃数对应的服务器，否则，判断各台服务器的权重是否相同，如果不同，按照权重加权随机选择，否则，随机选择。适应于服务器参数一致场景。
四、自适应负载均衡能力要求
- Gateway(Consumer) 端能够自动根据服务处理能力变化动态最优化分配请求保证较低响应时间，较高吞吐量；
- Provider 端能自动进行服务容量评估，当请求数量超过服务能力时，允许拒绝部分请求，以保证服务不过载；
- 当请求速率高于所有的 Provider 服务能力之和时，允许 Gateway( Consumer ) 拒绝服务新到请求。
五、自适应负载均衡设计目标
- 成功请求数最高
- TPS最大
六、自适应负载均衡与dubbo负载均衡区别
- dubbo随机算法、加权轮询算法、最小活跃数调用算法都使用到权重，但是这个权重是手动配置（写死的，无法被改变的），作为服务器的参数注册到注册中心，没有真正意义上实现自适应。
- 自适应负载均衡算法使用到的算法也离不开随机、加权、最小活跃数算法，但是权重的来源是随服务器当前运行状况动态平衡的，权重的计算来源可以是：服务器处理请求平均时长，任务队列阻塞任务数，活跃数等。
七、设计自适应负载均衡算法 – 动态计算权重
本次比赛小组计算权重是根据服务器的处理请求平均时长确定
7.1、自适应负载均衡流程设计
说明：服务器参数表是自己维护的ConcurrentHashMap,key为服务器IP，value为服务器的参数对象。
7.2、计算权重流程
- 开始接受请求：服务器都还没接收到请求时，按照轮询算法打流量，目的是为了获取各台服务器的参数，参数包括：平均处理请求时长，每台服务器的活跃数。
- 计算新权重：每台服务器都接收到请求后，根据返回参数计算每台服务器的权重，权重的计算依据每台服务器的平均处理请求时长。
weigth = weight + (500 / 平均处理时长)即平均处理时长越短，新权重会越大。 - 按照新权重加权按照概率随机打流量：
//在总权重中随机获取一个偏移量
int offsetWeight = ThreadLocalRandom.current().nextInt(totalWeight);
//遍历服务器列表
for (遍历服务器列表) {
int currentWeight = 获取当前服务器权重；
offsetWeight = offsetWeight - currentWeight;
if (offsetWeight < 0) {
选择该服务器
}
}
7.3、如何获取服务器参数
- 请求链路图如下：
- CallbackService：Consumer和Provider两端请求回调接口
- Filter：Consumer和Provider两端请求过滤器，dubbo开放该接口供开发者实现。
- 参数获取
- 服务器的活跃数：由于请求和返回都会调用Consumer端的filter接口，所以可以在Filter接口中设置自增字段，当请求某台服务器时，该服务器对应的自增字段加1，返回结果时，自增字段值减1。自增字段可以借助Dubbo内部维护的RpcStatus类实现。
- 服务器的总请求数：当请求调用Consumer端的filter接口时，请求数累加，总请求数保存在服务器参数表中（自己维护的ConcurrentHashMap,key为服务器IP，value为服务器的参数对象）。
- 服务器处理请求的平均时长：服务器处理一次请求时长计算方式有两种，一种是服务器真正处理请求的时长+网络延时，即当请求调用Consumer端的filter接口时，获取开始时间，处理结束后回调filter接口时获取结束时间，开始时间与结束时间的差值即一次处理请求的时长（时长包括网络延时），每次请求的时差累加，将总时长保存在该服务器的参数表中；另外一种是只在Provide端处理的时长，不包括网络延时，即当请求到达Provider端Filter接口时，获取当前时间，服务处理结束时，获取结束时间，两者的时差作为一次处理请求的时长，每次请求的时差累加，通过回调CallbackService接口将参数以字符串的形式返回Consumer端，Consumer端CallbakService接收到返回字符串处理后将总时长保存在该服务器的参数表中。
- 权重计算
- 从服务器列表选择服务器的时候，遍历服务器列表，从服务器参数表中获取服务器的总时长，总的请求数，服务器的处理请求平均时长 = 总请求数 / 总时长。
- 新权重 = 原始权重 + 500 / 平均时长。即平均处理时长越短，服务器性能越好，权重越大。
八、dubbo负载均衡源码分析
8.1、随机算法
流程图：
源码分析：
/**
* random load balance.
*/
public class RandomLoadBalance extends AbstractLoadBalance {
public static final String NAME = "random";
@Override
protected Invoker doSelect(List> invokers, URL url, Invocation invocation) {
// Number of invokers 服务器数量
int length = invokers.size();
// Every invoker has the same weight? 默认开始每台服务器的权重一样
boolean sameWeight = true;
// the weight of every invokers 每台服务器的权重
int[] weights = new int[length];
// the first invoker's weight 第一台服务器的权重，作为比较值
int firstWeight = getWeight(invokers.get(0), invocation);
weights[0] = firstWeight;
// The sum of weights 总权重值
int totalWeight = firstWeight;
//获取各台服务器的权重值，总权重值，各台服务器权重值是否相同标志
for (int i = 1; i < length; i++) {
int weight = getWeight(invokers.get(i), invocation);
// save for later use
weights[i] = weight;
// Sum
totalWeight += weight;
if (sameWeight && weight != firstWeight) {
sameWeight = false;
}
}
//各台服务器权重值不相同，加权分配概率，获取一台
if (totalWeight > 0 && !sameWeight) {
// If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
//按照权重分配各台服务器获取到的概率，通过偏移量表现概率问题，比如三台服务器，权重【2，5，1】，总权重是8，在总权重中随机取到
//2，5，1的概率分别是2/8，5/8，1/8。
int offset = ThreadLocalRandom.current().nextInt(totalWeight);
// Return a invoker based on the random value.
for (int i = 0; i < length; i++) {
offset -= weights[i];
if (offset < 0) {
return invokers.get(i);
}
}
}
// If all invokers have the same weight value or totalWeight=0, return evenly.
return invokers.get(ThreadLocalRandom.current().nextInt(length));
}
}
8.2、哈希算法
一致性哈希算法：相同参数的请求总是发到同一提供者，当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。缺省用 160 份虚拟节点。
流程图：
源码分析：
/**
* ConsistentHashLoadBalance
*/
public class ConsistentHashLoadBalance extends AbstractLoadBalance {
public static final String NAME = "consistenthash";
private final ConcurrentMap> selectors = new ConcurrentHashMap>();
@SuppressWarnings("unchecked")
@Override
protected Invoker doSelect(List> invokers, URL url, Invocation invocation) {
String methodName = RpcUtils.getMethodName(invocation);
String key = invokers.get(0).getUrl().getServiceKey() + "." + methodName;
int identityHashCode = System.identityHashCode(invokers);
ConsistentHashSelector selector = (ConsistentHashSelector) selectors.get(key);
if (selector == null || selector.identityHashCode != identityHashCode) {
selectors.put(key, new ConsistentHashSelector(invokers, methodName, identityHashCode));
selector = (ConsistentHashSelector) selectors.get(key);
}
return selector.select(invocation);
}
private static final class ConsistentHashSelector {
private final TreeMap> virtualInvokers;
private final int replicaNumber;
private final int identityHashCode;
private final int[] argumentIndex;
ConsistentHashSelector(List> invokers, String methodName, int identityHashCode) {
this.virtualInvokers = new TreeMap>();
this.identityHashCode = identityHashCode;
URL url = invokers.get(0).getUrl();
this.replicaNumber = url.getMethodParameter(methodName, HASH_NODES, 160);
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]);
}
for (Invoker invoker : invokers) {
String address = invoker.getUrl().getAddress();
for (int i = 0; i < replicaNumber / 4; i++) {
byte[] digest = md5(address + i);
for (int h = 0; h < 4; h++) {
long m = hash(digest, h);
virtualInvokers.put(m, invoker);
}
}
}
}
public Invoker select(Invocation invocation) {
String key = toKey(invocation.getArguments());
byte[] digest = md5(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 selectForKey(long hash) {
Map.Entry> entry = virtualInvokers.ceilingEntry(hash);
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;
}
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 = value.getBytes(StandardCharsets.UTF_8);
md5.update(bytes);
return md5.digest();
}
}
}
8.3、加权轮训算法
流程图：
源码分析：
/**
* 循环负载平衡
*/
public class RoundRobinLoadBalance extends AbstractLoadBalance {
public static final String NAME = "roundrobin";
private static final int RECYCLE_PERIOD = 60000;
protected static class WeightedRoundRobin {
private int weight;
private AtomicLong current = new AtomicLong(0);
private long lastUpdate;
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
current.set(0);
}
public long increaseCurrent() {
return current.addAndGet(weight);
}
public void sel(int total) {
current.addAndGet(-1 * total);
}
public long getLastUpdate() {
return lastUpdate;
}
public void setLastUpdate(long lastUpdate) {
this.lastUpdate = lastUpdate;
}
}
private ConcurrentMap> methodWeightMap = new ConcurrentHashMap>();
private AtomicBoolean updateLock = new AtomicBoolean();
/**
* get invoker addr list cached for specified invocation
*
* for unit test only
*
* @param invokers
* @param invocation
* @return
*/
protected Collection getInvokerAddrList(List> invokers, Invocation invocation) {
String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
Map map = methodWeightMap.get(key);
if (map != null) {
return map.keySet();
}
return null;
}
@Override
protected Invoker doSelect(List> invokers, URL url, Invocation invocation) {
String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
ConcurrentMap map = methodWeightMap.get(key);
if (map == null) {
methodWeightMap.putIfAbsent(key, new ConcurrentHashMap());
map = methodWeightMap.get(key);
}
int totalWeight = 0;
long maxCurrent = Long.MIN_VALUE;
long now = System.currentTimeMillis();
Invoker selectedInvoker = null;
WeightedRoundRobin selectedWRR = null;
for (Invoker invoker : invokers) {
String identifyString = invoker.getUrl().toIdentityString();
WeightedRoundRobin weightedRoundRobin = map.get(identifyString);
int weight = getWeight(invoker, invocation);
if (weightedRoundRobin == null) {
weightedRoundRobin = new WeightedRoundRobin();
weightedRoundRobin.setWeight(weight);
map.putIfAbsent(identifyString, weightedRoundRobin);
}
if (weight != weightedRoundRobin.getWeight()) {
//weight changed
weightedRoundRobin.setWeight(weight);
}
long cur = weightedRoundRobin.increaseCurrent();
weightedRoundRobin.setLastUpdate(now);
if (cur > maxCurrent) {
maxCurrent = cur;
selectedInvoker = invoker;
selectedWRR = weightedRoundRobin;
}
totalWeight += weight;
}
if (!updateLock.get() && invokers.size() != map.size()) {
if (updateLock.compareAndSet(false, true)) {
try {
// copy -> modify -> update reference
ConcurrentMap newMap = new ConcurrentHashMap();
newMap.putAll(map);
Iterator> it = newMap.entrySet().iterator();
while (it.hasNext()) {
Entry item = it.next();
if (now - item.getValue().getLastUpdate() > RECYCLE_PERIOD) {
it.remove();
}
}
methodWeightMap.put(key, newMap);
} finally {
updateLock.set(false);
}
}
}
if (selectedInvoker != null) {
selectedWRR.sel(totalWeight);
return selectedInvoker;
}
// should not happen here
return invokers.get(0);
}
}
8.4、最小活跃数算法
当有请求打向某台服务器时，该服务活跃数加1，当请求被处理结束，活跃数减1，活跃数量可以通过dubbo维护RpcStatus类存储。
流程图：
源码分析
public class LeastActiveLoadBalance extends AbstractLoadBalance {
public static final String NAME = "leastactive";
private final Random random = new Random();
protected Invoker doSelect(List> 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 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)]);
}
}
九、自适应负载均衡源码地址
github地址：https://github.com/RuiDer/LoadBalance