微服务的几种负载均衡算法

目录

一、负载均衡

二、负载均衡算法

1、静态负载均衡

2、动态负载均衡

三、Dubbo负载均衡的四种算法

1、基于权重随机算法RandomLoadBalance

2、基于最少活跃数算法LeastActiveLoadBalance

3、基于一致性hash算法ConsistentHashLoadBalance

4、基于加权轮询算法RoundRobinLoadBalance


一、负载均衡

负载均衡简单的说就是对流量进行重新分配,避免单一机器直接被较为集中的流量击穿,或者避免部分机器由于没有合理分配流量导致空闲。

负载均衡分位硬件负载均衡和软件负载均衡,这里主要对软件负载均衡进行一个记录。

软件方面的产品比较流行的有LVS、Nginx、HaProxy等。

二、负载均衡算法

负载均衡算法分位静态负载均衡和动态负载均衡。

1、静态负载均衡

①轮询法

轮询是将客户端的请求轮流分配到每一个节点上,当有5台机器的时候,来5个请求,每台机器都将得到一次请求,并不会关心服务器实际的连接数和当前的系统负载。

②随机法

随机法顾名思义就是客户端请求会随机选取一台服务器进行访问,当客户端调用服务器的次数增多的时候,每台机器获得的请求数是差不多的,也就是平均分配了。

③源地址哈希法

源地址哈希是获取客户端的ip地址,通过哈希算法得出一个值,通过该值对后端服务器列表大小进行取模,返回的结果就是客户端要访问的服务器的序号。

通过上述介绍,可以知道,同一个ip地址的请求,都会打在后端同一台机器上进行访问,这个也可以用于进行本地session、本地缓存的场景。

但是该方法无法保证高可用,如果后端一个节点出现故障,会导致改节点上的客户端无法使用;并且如果某个用户是热点用户,巨大的流量都会打在同一台机器上,导致流量分布不均衡。

④加权轮询法

不同的后端服务器配置可能不同,因此能承受的流量也不同,使用加权法,可以让配置高的机器得到更大的权重,处理更多的请求。降低配置低的机器的请求。

2、动态负载均衡

动态负载均衡需要根据之前的结果进行运算后才确定的算法,需要保存之前的结果和将结果进行计算,理论上动态算法比静态算法在调度过程中更消耗资源。

①最小连接数

根据后端服务器当前的连接情况,动态的选择当前连接数最少的一个节点处理当前请求,这个可以提高整个集群的运转效率,但是也提高了复杂度,在每次调用的连接和断开时都需要进行计数。

②最快响应速度法

根据请求的响应时间,动态调整每个节点的权重,将响应速度更快的机器分配更多的权重,响应速度慢的分配更少的权重。同时提高了复杂度,每次调用都要计算请求的响应时间。

三、Dubbo负载均衡的四种算法

微服务的Dubbo中,是怎么实现的呢?我们通过源码来看一下:

微服务的几种负载均衡算法_第1张图片

Dubbo中实现负载均衡有个基类:AbstractLoadBalance:

public abstract class AbstractLoadBalance implements LoadBalance {
    public AbstractLoadBalance() {
    }

    public  Invoker select(List> invokers, URL url, Invocation invocation) {
        if (invokers != null && !invokers.isEmpty()) {
            // 如果 invokers 列表中仅有一个 Invoker,直接返回即可,无需进行负载均衡
            // 否则调用 doSelect 方法进行负载均衡,该方法为抽象方法,由子类实现
            return invokers.size() == 1 ? (Invoker)invokers.get(0) : this.doSelect(invokers, url, invocation);
        } else {
            return null;
        }
    }

    protected abstract  Invoker doSelect(List> var1, URL var2, Invocation var3);
    
    // 服务提供者权重计算逻辑
    protected int getWeight(Invoker invoker, Invocation invocation) {
        // 获取 weight 配置值
        int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), "weight", 100);
        if (weight > 0) {
            // 获取服务提供者启动时间戳
            long timestamp = invoker.getUrl().getParameter("remote.timestamp", 0L);
            if (timestamp > 0L) {    
                // 计算服务提供者运行时长
                int uptime = (int)(System.currentTimeMillis() - timestamp);
                // 获取服务预热时间,默认为10分钟
                int warmup = invoker.getUrl().getParameter("warmup", 600000);
                // 如果服务运行时间小于预热时间,则重新计算服务权重,即降权
                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
        int ww = (int)((float)uptime / ((float)warmup / (float)weight));
        return ww < 1 ? 1 : (ww > weight ? weight : ww);
    }
}

可以看到下面有四种实现算法:

1、ConsistentHashLoadBalance:基于一致性hash算法

2、LeastActiveLoadBalance:基于最少活跃数算法

3、RandomLoadBalance:基于权重随机算法

4、RoundRobinLoadBalance:基于加权轮询算法

1、基于权重随机算法RandomLoadBalance

这个算法是Dubbo的默认负载均衡算法,基于权重进行分配,如果没有进行权重分配,那么每个分配到比列是一样的,基本可以认为是轮询算法。 RandomLoadBalance算法在经过多次请求后,能够将调用请求按照权重值进行均匀分配。

一起看一下代码:

public class RandomLoadBalance extends AbstractLoadBalance {
    public static final String NAME = "random";
    private final Random random = new Random();

    public RandomLoadBalance() {
    }

    protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
        // 后端服务器节点是invokers,获取节点大小
        int length = invokers.size();
        // 累加权重
        int totalWeight = 0;
        // 权重标识
        boolean sameWeight = true;

        int offset;
        int i;
        // 计算总权重 totalWeight
        // 检测每个服务提供者的权重是否相同,若不相同,则将 sameWeight 置为 false
        for(offset = 0; offset < length; ++offset) {
            i = this.getWeight((Invoker)invokers.get(offset), invocation);
            totalWeight += i;
            // 检测当前服务提供者的权重与上一个服务提供者的权重是否相同,
            // 不相同的话,则将 sameWeight 置为 false。
            if (sameWeight && offset > 0 && i != this.getWeight((Invoker)invokers.get(offset - 1), invocation)) {
                sameWeight = false;
            }
        }
        // 进行随机数落在哪一个权重区间的判断

        if (totalWeight > 0 && !sameWeight) {
            // 基于总的权重数计算出随机数
            offset = this.random.nextInt(totalWeight);
            // 编辑后端服务节点,看随机数是否落在节点之内,如果是被选中
            // 循环让 offset 数减去服务提供者权重值,当 offset 小于0时,返回相应的 Invoker。
            for(i = 0; i < length; ++i) {
                // 让随机值 offset 减去权重值
                offset -= this.getWeight((Invoker)invokers.get(i), invocation);
                if (offset < 0) {
                    // 返回相应的 Invoker
                    return (Invoker)invokers.get(i);
                }
            }
        }
        // 如果权重相等,就按照直接的随机算法
        return (Invoker)invokers.get(this.random.nextInt(length));
    }
}

2、基于最少活跃数算法LeastActiveLoadBalance

这个算法会判断机器目前的连接数,连接数少的就会接收更多的请求进行处理。但默认是认为机器越好,处理速度越快。则连接数越少,但如果实际机器性能不好,这个算法就比较不那么好了。

public class LeastActiveLoadBalance extends AbstractLoadBalance {
    public static final String NAME = "leastactive";
    private final Random random = new Random();

    public LeastActiveLoadBalance() {
    }

    protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
        int length = invokers.size();
        // 最小的活跃数
        int leastActive = -1;
        // 具有相同,最小的活跃数
        int leastCount = 0;
        // leastIndexs 用于记录具有相同“最小活跃数”的 Invoker 在 invokers 列表中的下标信息
        int[] leastIndexs = new int[length];
        int totalWeight = 0;
        // 第一个最小活跃数的 Invoker 权重值,用于与其他具有相同最小活跃数的 Invoker 的权重进行对比,
        // 以检测是否所有具有相同最小活跃数的 Invoker 的权重均相
        int firstWeight = 0;
        boolean sameWeight = true;

        int offsetWeight;
        int leastIndex;   
        // 遍历每一个invoker,找出最小的连接数
        for(offsetWeight = 0; offsetWeight < length; ++offsetWeight) {
            Invoker invoker = (Invoker)invokers.get(offsetWeight);
            // 获取活跃数
            leastIndex = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive();
            // 获取权重
            int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), "weight", 100);
            // 判断该活跃数是不是比已经取到的最小活跃数还要小
            if (leastActive != -1 && leastIndex >= leastActive) {
                // 如果目前的活跃数与最小活跃数相等,则进行权重的判断
                if (leastIndex == leastActive) {
                    // 当前 Invoker 的活跃数 active 与最小活跃数 leastActive 相同
                    leastIndexs[leastCount++] = offsetWeight;
                    // 累加权重
                    totalWeight += weight;
                    // 检测当前 Invoker 的权重与 firstWeight 是否相等,
                    // 不相等则将 sameWeight 置为 false
                    if (sameWeight && offsetWeight > 0 && weight != firstWeight) {
                        sameWeight = false;
                    }
                }
            } else {
                // 使用当前活跃数 active 更新最小活跃数 leastActive
                leastActive = leastIndex;
                // 更新 leastCount 为 1
                leastCount = 1;
                // 记录当前下标值到 leastIndexs 中
                leastIndexs[0] = offsetWeight;
                totalWeight = weight;
                firstWeight = weight;
                sameWeight = true;
            }
        }
        // 如果最小活跃数只有一个,则返回
        if (leastCount == 1) {
            return (Invoker)invokers.get(leastIndexs[0]);
        } else {
            // 如果最小活跃数有多个,进行权重的判断,算法与RoandomLoadBalance一致
            if (!sameWeight && totalWeight > 0) {
                // 随机获取一个 [0, totalWeight) 之间的数字
                offsetWeight = this.random.nextInt(totalWeight);
                // 循环让随机数减去具有最小活跃数的 Invoker 的权重值,
                // 当 offset 小于等于0时,返回相应的 Invoker
                for(int i = 0; i < leastCount; ++i) {
                    leastIndex = leastIndexs[i];
                    offsetWeight -= this.getWeight((Invoker)invokers.get(leastIndex), invocation);
                    if (offsetWeight <= 0) {
                        return (Invoker)invokers.get(leastIndex);
                    }
                }
            }
            // 如果权重也是相等的,随机返回一个
            return (Invoker)invokers.get(leastIndexs[this.random.nextInt(leastCount)]);
        }
    }
}

这里简单说一下LeastActiveLoadBalance的算法逻辑:

①遍历invokers列表,寻找活跃数最小的Invoker,如果有多个相同的最小活跃数,则记录下来

②在记录下来的数据中,比较权重值是否相等

③如果只有一个Invoker具有最小活跃数,则直接返回即可

④如果有多个Invoker具有最小活跃数,并且权重不一致,则使用RoandomLoadBalance算法处理

⑤如果有多个Invoker具有最小活跃数,但权重相等,则随机返回一个即可

3、基于一致性hash算法ConsistentHashLoadBalance

关于一致性hash算法的一些介绍,可以参考:

五分钟看懂一致性哈希算法 - 掘金

简单的说就是定义一组hash是在0-2^32-1之间,然后每个服务器计算出一个hash值,定位在0-2^32-1上面,然后每个请求对象也会计算出一个hash值,然后找到第一个比对象hash值大的服务器的hash值,然后该对象就缓存在该服务器上。如果找不到比该对象大的服务器的hash值,则缓存到第一个服务器上,即hash值最小的服务器上。

如果服务器较少,可以引入虚拟节点,比如两个服务器A、B,则引入虚拟节点A1、A2、A3、B1、B2、B3,此时就有6个hash值,然后A1、A2、A3对应A服务器,B1、B2、B3对应B服务器,然后再按照上面的方式找到对应的缓存服务器即可。

看一下源码:

public class ConsistentHashLoadBalance extends AbstractLoadBalance {
    private final ConcurrentMap> selectors = new ConcurrentHashMap();

    public ConsistentHashLoadBalance() {
    }

    protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
        String key = ((Invoker)invokers.get(0)).getUrl().getServiceKey() + "." + invocation.getMethodName();
        // 获取 invokers 原始的 hashcode
        int identityHashCode = System.identityHashCode(invokers);
        ConsistentHashLoadBalance.ConsistentHashSelector selector = (ConsistentHashLoadBalance.ConsistentHashSelector)this.selectors.get(key);
        // 如果 invokers 是一个新的 List 对象,意味着服务提供者数量发生了变化,可能新增也可能减少了。
        // 此时 selector.identityHashCode != identityHashCode 条件成立
        if (selector == null || selector.identityHashCode != identityHashCode) {
            // 创建新的 ConsistentHashSelector
            this.selectors.put(key, new ConsistentHashLoadBalance.ConsistentHashSelector(invokers, invocation.getMethodName(), identityHashCode));
            selector = (ConsistentHashLoadBalance.ConsistentHashSelector)this.selectors.get(key);
        }
        // 调用 ConsistentHashSelector 的 select 方法选择 Invoker
        return selector.select(invocation);
    }

    private static final class ConsistentHashSelector {
        private final TreeMap> virtualInvokers = new TreeMap();
        private final int replicaNumber;
        private final int identityHashCode;
        private final int[] argumentIndex;

        ConsistentHashSelector(List> invokers, String methodName, int identityHashCode) {
            this.identityHashCode = identityHashCode;
            URL url = ((Invoker)invokers.get(0)).getUrl();
            // 获取虚拟节点数,默认为160
            this.replicaNumber = url.getMethodParameter(methodName, "hash.nodes", 160);
            // 获取参与 hash 计算的参数下标值,默认对第一个参数进行 hash 运算
            String[] index = Constants.COMMA_SPLIT_PATTERN.split(url.getMethodParameter(methodName, "hash.arguments", "0"));
            this.argumentIndex = new int[index.length];

            for(int i = 0; i < index.length; ++i) {
                this.argumentIndex[i] = Integer.parseInt(index[i]);
            }

            Iterator i$ = invokers.iterator();

            while(i$.hasNext()) {
                Invoker invoker = (Invoker)i$.next();
                String address = invoker.getUrl().getAddress();

                for(int i = 0; i < this.replicaNumber / 4; ++i) {
                    // 对 address + i 进行 md5 运算,得到一个长度为16的字节数组
                    byte[] digest = this.md5(address + i);
                    // 对 digest 部分字节进行4次 hash 运算,得到四个不同的 long 型正整数
                    for(int h = 0; h < 4; ++h) {
                        // h = 0 时,取 digest 中下标为 0 ~ 3 的4个字节进行位运算
                        // h = 1 时,取 digest 中下标为 4 ~ 7 的4个字节进行位运算
                        // h = 2,取 digest 中下标为 8 ~ 11 的4个字节进行位运算 
                        // h = 3 时过程同上
                        long m = this.hash(digest, h);
                        // 将 hash 到 invoker 的映射关系存储到 virtualInvokers 中,
                        // virtualInvokers 中的元素要有序,因此选用 TreeMap 作为存储结构
                        this.virtualInvokers.put(m, invoker);
                    }
                }
            }

        }

        public Invoker select(Invocation invocation) {
            // 将参数转为 key
            String key = this.toKey(invocation.getArguments());
            // 对参数 key 进行 md5 运算
            byte[] digest = this.md5(key);
            // 取 digest 数组的前四个字节进行 hash 运算,再将 hash 值传给 selectForKey 方法,
            // 寻找合适的 Invoker
            return this.selectForKey(this.hash(digest, 0));
        }

        private String toKey(Object[] args) {
            StringBuilder buf = new StringBuilder();
            int[] arr$ = this.argumentIndex;
            int len$ = arr$.length;

            for(int i$ = 0; i$ < len$; ++i$) {
                int i = arr$[i$];
                if (i >= 0 && i < args.length) {
                    buf.append(args[i]);
                }
            }

            return buf.toString();
        }

        private Invoker selectForKey(long hash) {
            // 到 TreeMap 中查找第一个节点值大于或等于当前 hash 的 Invoker
            Entry> entry = this.virtualInvokers.tailMap(hash, true).firstEntry();
            // 如果 hash 大于 Invoker 在圆环上最大的位置,此时 entry = null,
            // 需要将 TreeMap 的头结点赋值给 entry
            if (entry == null) {
                entry = this.virtualInvokers.firstEntry();
            }
            // 返回 Invoker
            return (Invoker)entry.getValue();
        }

        private long hash(byte[] digest, int number) {
            return ((long)(digest[3 + number * 4] & 255) << 24 | (long)(digest[2 + number * 4] & 255) << 16 | (long)(digest[1 + number * 4] & 255) << 8 | (long)(digest[number * 4] & 255)) & 4294967295L;
        }

        private byte[] md5(String value) {
            MessageDigest md5;
            try {
                md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException var6) {
                throw new IllegalStateException(var6.getMessage(), var6);
            }

            md5.reset();

            byte[] bytes;
            try {
                bytes = value.getBytes("UTF-8");
            } catch (UnsupportedEncodingException var5) {
                throw new IllegalStateException(var5.getMessage(), var5);
            }

            md5.update(bytes);
            return md5.digest();
        }
    }
}

4、基于加权轮询算法RoundRobinLoadBalance

对于轮询而言,假设我们有三台服务器A、B、C,我们将收到的第一个请求给A,第二个给B、第三个给C、第四个给A、第五个给B......这种方式就是轮询,这里是默认每台机器的性能相近,但实际上并不会这样,因此有了加权,也就是调控每台服务器被调用的比列。比如给A、B、C分别设置权重5:3:2,则10次请求中5次分配给A,3次分配给B,2次分配给C。

源码如下:

public class RoundRobinLoadBalance extends AbstractLoadBalance {
    public static final String NAME = "roundrobin";
    private final ConcurrentMap sequences = new ConcurrentHashMap();

    public RoundRobinLoadBalance() {
    }

    protected  Invoker doSelect(List> invokers, URL url, Invocation invocation) {
        // key = 全限定类名 + "." + 方法名
        String key = ((Invoker)invokers.get(0)).getUrl().getServiceKey() + "." + invocation.getMethodName();
        int length = invokers.size();
        // 最大权重
        int maxWeight = 0;
        // 最小权重
        int minWeight = 2147483647;
        LinkedHashMap, RoundRobinLoadBalance.IntegerWrapper> invokerToWeightMap = new LinkedHashMap();
        // 权重总和
        int weightSum = 0;

        int currentSequence;
        // 查找最大和最小权重,计算权重总和等
        for(int i = 0; i < length; ++i) {
            currentSequence = this.getWeight((Invoker)invokers.get(i), invocation);
            // 获取最大和最小权重
            maxWeight = Math.max(maxWeight, currentSequence);
            minWeight = Math.min(minWeight, currentSequence);
            if (currentSequence > 0) {
                // 将 currentSequence封装到 IntegerWrapper 中
                invokerToWeightMap.put(invokers.get(i), new RoundRobinLoadBalance.IntegerWrapper(currentSequence));
                // 累加权重
                weightSum += currentSequence;
            }
        }
        // 查找AtomicPositiveInteger对应的实例,如果为null就创建一个实例
        AtomicPositiveInteger sequence = (AtomicPositiveInteger)this.sequences.get(key);
        if (sequence == null) {
            this.sequences.putIfAbsent(key, new AtomicPositiveInteger());
            sequence = (AtomicPositiveInteger)this.sequences.get(key);
        }
        // 获取当前的调用编号
        currentSequence = sequence.getAndIncrement();
        // 如果 最小权重 < 最大权重,表明服务提供者之间的权重是不相等的
        if (maxWeight > 0 && minWeight < maxWeight) {
            // 使用调用编号对权重总和进行取余操作
            int mod = currentSequence % weightSum;
            // 进行 maxWeight 次遍历
            for(int i = 0; i < maxWeight; ++i) {
                // 对invokerToWeightMap进行迭代遍历
                Iterator i$ = invokerToWeightMap.entrySet().iterator();

                while(i$.hasNext()) {
                    Entry, RoundRobinLoadBalance.IntegerWrapper> each = (Entry)i$.next();
                    // 获取 Invoker
                    Invoker k = (Invoker)each.getKey();
                    // 获取权重包装类 IntegerWrapper
                    RoundRobinLoadBalance.IntegerWrapper v = (RoundRobinLoadBalance.IntegerWrapper)each.getValue();
                    // 如果 mod = 0,且权重大于0,此时返回相应的 Invoker
                    if (mod == 0 && v.getValue() > 0) {
                        return k;
                    }
                    // mod != 0,且权重大于0,此时对权重和 mod 分别进行自减操作
                    if (v.getValue() > 0) {
                        v.decrement();
                        --mod;
                    }
                }
            }
        }
        // 返回Invoker
        return (Invoker)invokers.get(currentSequence % length);
    }
    
    private static final class IntegerWrapper {
        private int value;

        public IntegerWrapper(int value) {
            this.value = value;
        }

        public int getValue() {
            return this.value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public void decrement() {
            --this.value;
        }
    }
}

你可能感兴趣的:(框架及三方组件,Java学习,微服务,微服务,负载均衡,microservices)