负载均衡算法原理解析（一）

最新推荐文章于 2024-08-19 16:00:00 发布
最新推荐文章于 2024-08-19 16:00:00 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： 算法 spring cloud 文章标签： 负载均衡 loadbanlance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzygcs/article/details/86622651
版权

最近在学习Spring Cloud的Ribbon组件，里面用到了一些负载均衡算法。下面就来研究下当前常规的一些负载均衡算法实现，像权重随机、加权轮询、一致性哈希、最少活跃调用数等。

负载均衡介绍

负载均衡，英文名称为LoadBalance，它的职责是将网络请求，或者其他形式的负载“均摊”到不同的机器上。避免集群中部分服务器压力过大，而另一些服务器比较空闲的情况。负载均衡能够解决大量并发访问服务问题，这种集群技术可以用最少的投资获得接近于大型主机的性能。

负载均衡可分为软件负载均衡和硬件负载均衡。硬件负载均衡有F5、Array，软件负载均衡有Nginx、LVS、HAProxy等。

算法实现

初始准备

定义一个服务器列表，每个负载均衡算法会从中挑出一个服务器作为算法的结果。

public class ServerIps {

    // 服务器清单
    public static final List<String> LIST = new ArrayList<>();
    // 带有权重值的服务器清单
    public static final Map<String, Integer> WEIGHT_LIST = new HashMap<>();
    // 带有当前服务器活跃数的服务器清单
    public static final Map<String, Integer> ACTIVITY_LIST = new LinkedHashMap<>();

    static {
        LIST.add("192.168.1.1");
        LIST.add("192.168.1.2");
        LIST.add("192.168.1.3");
        LIST.add("192.168.1.4");
        LIST.add("192.168.1.5");
        LIST.add("192.168.1.6");
        LIST.add("192.168.1.7");
        LIST.add("192.168.1.8");
        LIST.add("192.168.1.9");
        LIST.add("192.168.1.10");

        WEIGHT_LIST.put("192.168.1.1", 9);
        WEIGHT_LIST.put("192.168.1.2", 1);
        WEIGHT_LIST.put("192.168.1.3", 8);
        WEIGHT_LIST.put("192.168.1.4", 2);
        WEIGHT_LIST.put("192.168.1.5", 7);
        WEIGHT_LIST.put("192.168.1.6", 3);
        WEIGHT_LIST.put("192.168.1.7", 6);
        WEIGHT_LIST.put("192.168.1.8", 4);
        WEIGHT_LIST.put("192.168.1.9", 5);
        WEIGHT_LIST.put("192.168.1.10", 5);
		
	    ACTIVITY_LIST.put("192.168.1.1", 2);
        ACTIVITY_LIST.put("192.168.1.2", 0);
        ACTIVITY_LIST.put("192.168.1.3", 1);
        ACTIVITY_LIST.put("192.168.1.4", 3);
        ACTIVITY_LIST.put("192.168.1.5", 0);
        ACTIVITY_LIST.put("192.168.1.6", 1);
        ACTIVITY_LIST.put("192.168.1.7", 4);
        ACTIVITY_LIST.put("192.168.1.8", 2);
        ACTIVITY_LIST.put("192.168.1.9", 7);
        ACTIVITY_LIST.put("192.168.1.10", 3);
    }
}
加权随机-RandoomLoadBalance

先来个简单的随机实现：

public static String getServer() {
	Random random = new Random();
	int pos = random.nextInt(ServerIps.LIST.size());
	return ServerIps.LIST.get(pos);
}

Ribbon中的RandomRule的实现原理就是就是这种方式，有兴趣的可以去看下。这种算法适用于每台机器的性能差不多的时候，而实际生产中经常会存在某些机器的性能更好，它可以处理更多的请求，所以，我们可以对每台机器设置一个权重。

实现思路：
假设我们有一组服务器servers=[A,B,C]，它们对应的权重为weights=[5,3,2]，权重总和为10。现在把这些权值平铺在一维坐标上，[0，5)区间属于服务器A，[5,8)区间属于服务B，[8,10)区间属于服务器C。接下来通过随机数生成器生成一个范围在[0,10)之间的随机数，然后计算这个随机数回落到哪个区间上。比如数字3会落到服务器A对应的区间上，此时返回服务器A即可。

权重越大的机器，在坐标轴上对应的区间范围越大，因此随机数生成器生成的数字就会有更大的概率落到此区间内。只要随机数生成器产生的随机分布性很好，在经过多次选择后，每个服务器被选中的次数比例接近其权重比例。

假设现在随机数offset=7:

  • 1.offset<5 is false，所以不再[0,5)区间，将offset=offset-5（offset=2）
  • 2.offset<3 is true，所以处于[5,8)区间，应选用B服务器

实现如下：

// 加权随机
public class RandomLoadBalance {

    public static String getServer() {
        boolean sameWeight = true; // 是否所有权重都相等
        int totalWeight = 0; // 总权重
        
        Object[] weightArray =  ServerIps.WEIGHT_LIST.values().toArray();
        for (int i = 0; i < weightArray.length; i++) {
            Integer weight = (Integer) weightArray[i];
            totalWeight += weight;
            if (sameWeight && i > 0 && weight != weightArray[i - 1]) {
                sameWeight = false;
            }
        }

        Random rand = new Random();
        int pos = rand.nextInt(totalWeight);
        
        if (!sameWeight) {
            for (String key : ServerIps.WEIGHT_LIST.keySet()) {
                if (pos < ServerIps.WEIGHT_LIST.get(key)) {
                    return key;
                }
                pos = pos - ServerIps.WEIGHT_LIST.get(key);
            }
        }

        // 如果所有权重都相等，随机一个IP
        return (String) ServerIps.WEIGHT_LIST.keySet().toArray()[rand.nextInt(ServerIps.WEIGHT_LIST.size())];
    }
}
加权轮询-RoundRobinLoadBalance

先来一个简单的轮询算法：

public static String getServer() {
	String ip = null;
	synchronized (pos) {
		if (pos >= ServerIps.LIST.size()) {
			pos = 0;
		}
		ip = ServerIps.LIST.get(pos);
		pos++;
	}
	
	return ip;
}

Robbion中的RoundRobinRule是通过next = (current + 1) % modulo;取余来实现轮询，和上面的实现原理类似。这种算法很简单，也很公平，每台服务轮流来进行服务，但是就像前面说的，生产环境中机器的性能分配不均，所以需要加上一个权重来重新实现该算法。

实现思路：

调用编号: 通过这个编号来模拟请求，比如第1次调用为1，第2次调用为2，第100次调用为100，调用编号是递增的。

假设我们有三台服务器servers=[A,B,C]，对应的权重为weights=[2,5,1]，总权重为8，我们可以理解为有8台服务器，其中两台为A，5台为B，1台为C。一次调用过来时，需要按顺序访问，比如有10次访问，那么调用顺序为AABBBBBCAA，调用编号会越来越大，而服务器是固定的，所以需要把调用编号“缩小”，我们可以借鉴Robbion中RoundRobinRule的方式，通过取余，除数为总权重和。通过取余，调用编号会被缩小为0-7之间的8个数字。

和权重随机算法类似，可以把权重想象为一个一维坐标轴“0–2-----7-8”

  • 1号调用，1%8=1，offset=1，offset<=2 is true，取A；
  • 2号调用，2%8=2，offset=2，offset<=2 is true，取A；
  • 3号调用，3%8=3，offset=3，offset<=2 is false，offset=offset-2，offset=1，offset<=5，取B；
  • 8号调用，8%8=0，offset=0，特殊情况，offset = 8，offset <= 2 is false, offset = offset - 2, offset = 6，offset <= 5 is false, offset = offset - 5, offset = 1, offset <= 1 is true, 取C;
    …
  • 100号调用，100%8=4，offset=4 …

实现如下：
模拟调用编号生成

public class Sequence {
    private static Integer sequenceNum = 0;
    public static Integer getAndIncrement() {
        return sequenceNum++;
    }
}

// 加权轮询
public class RoundRobinLoadBalance {

    private static Integer offset = 0;

    public static String getServer() {
        boolean sameWeight = true; // 是否所有权重都相等
        int totalWeight = 0; // 总权重
        
        Object[] weightArray = ServerIps.WEIGHT_LIST.values().toArray();
        for (int i = 0; i < weightArray.length; i++) {
            Integer weight = (Integer) weightArray[i];
            totalWeight += weight;
            if (sameWeight && i > 0 && weight != weightArray[i - 1]) {
                sameWeight = false;
            }
        }

        Integer sequenceNum = Sequence.getAndIncrement();
        offset = sequenceNum % totalWeight;
        if (offset == 0) {
            offset = totalWeight;
        }

        if (!sameWeight) {
            for (String key : ServerIps.WEIGHT_LIST.keySet()) {
                if (offset <= ServerIps.WEIGHT_LIST.get(key)) {
                    return key;
                }
                offset = offset - ServerIps.WEIGHT_LIST.get(key);
            }
        }

        // 如果权重都相等，则按照简单轮询策略
        String serverIp = "";
        synchronized (offset) {
            if (offset >= ServerIps.WEIGHT_LIST.size()) {
                offset = 0;
            }
            serverIp = (String) ServerIps.WEIGHT_LIST.keySet().toArray()[offset];
            offset++;
        }

        return serverIp;
    }
}

循环调用执行后，就会发现这种算法有一个缺点：一台服务器的权重特别大的时候，它需要连续的处理请求。但是实际上我们想达到的效果是: 对于权重为8的服务器IP，总权重为50，100次请求中，该服务只要有100*8/50=16次访问就够了，而且这16次不一定要连续访问。比如假设有三台服务器servers=[A,B,C]，对应的权重为weights=[5,1,1]，总权重为7，那么上述这个算法的结果是：AAAAABC。我们希望是这样一个结果：AABACAA，把B和C平均插入到5个A中间，这样就比较均衡了。

下面再来介绍下升级版的算法，平滑加权轮询：
实现思路：

每个服务器对应两个权重，分别为weight和currentWeight。其中weight是固定的，currentWeight会动态调整，初始值为0。当有新的请求进来时，遍历服务器列表，让它的currentWeight加上自身权重。遍历完成后，找到最大的currentWeight，并将其减去权重总和，然后返回相应的服务器即可。

请求编号currentWeight数组(current_Weight += weight)选择结果(max(currentWeight))减去权重总和后的currentWeight数组(max(currentWeight)-=sum(weight))
1[5,1,1]A[-2,1,1]
2[3,2,2]A[-4,2,2]
3[1,3,3]B[1,-4,3]
4[6,-3,4]A[-1,-3,4]
5[4,-2,5]C[4,-2,-2]
6[9,-1,-1]A[2,-1,-1]
7[7,0,0]A[0,0,0]

如上，经过平滑性处理后，得到的服务器序列为[A,A,B,A,C,A,A]。初始情况下currentWeight=[0,0,0]，第7个请求处理完后，currentWeight再次变为[0,0,0]
。

实现如下：
为了演示方便，这里将ServerIps.WEIGHT_LIST中的值改为：

WEIGHT_LIST.put("A",5);
WEIGHT_LIST.put("B",1);
WEIGHT_LIST.put("C",1);

// 该类用来保存ip，weight(固定不变的原始权重)，currentWeight(动态变化的权重)。
public class Weight {
    private Integer weight;
    private Integer currentWeight;
    private String ip;

    public Weight(Integer weight, Integer currentWeight, String ip) {
        this.weight = weight;
        this.currentWeight = currentWeight;
        this.ip = ip;
    }
	...省略getter/setter方法
}

// 平滑加权轮询
public class RoundRobinLoadBalanceV1 {
    private static Map<String, Weight> weightMap = new HashMap<>();
    private static Weight currentWeight;

    public static String getServer() {
    	// 获取总权重
        int totalWeight = ServerIps.WEIGHT_LIST.values().stream().reduce(0, (w1, w2) -> w1 + w2);

        // 初始化weightMap，初始时将currentWeight赋值为weight
        if (weightMap.isEmpty()) {
            for (String ip : ServerIps.WEIGHT_LIST.keySet()) {
                Integer weight = ServerIps.WEIGHT_LIST.get(ip);
                weightMap.put(ip, new Weight(weight, weight, ip));
            }
        }

        // 找出currentWeight的最大值
        Weight maxCurrentWeight = null;
        for (Weight weight : weightMap.values()) {
            if (maxCurrentWeight == null || weight.getCurrentWeight() > maxCurrentWeight.getCurrentWeight()) {
                maxCurrentWeight = weight;
            }
        }

        // 将maxCurrentWeight减去总权重和
        maxCurrentWeight.setCurrentWeight(maxCurrentWeight.getCurrentWeight() - totalWeight);

        // 所有的ip的currenntWeight统一加上原始权重
        for (Weight weight : weightMap.values()) {
            weight.setCurrentWeight(weight.getCurrentWeight() + weight.getWeight());
        }

        return maxCurrentWeight.getIp();

    }

    public static void main(String[] args) {
        for (int i = 0; i < 7; i++) {
            System.out.println(getServer());
        }
    }
}

执行结果：
平滑轮询
看到这里是不是很Surprise，第一次看到这个结果的时候，感觉算法是如此的有魅力。

负载均衡算法原理解析（二）
注意
本文提到的算法以理解实现思想为主，实际生产环境要复杂很多，还需要做更多的处理。

参考资料
http://dubbo.apache.org/zh-cn/docs/source_code_guide/loadbalance.html

------------本文结束感谢您的阅读------------
岸远水声微
关注
专栏目录
负载均衡算法
hezhanran的博客
12-21 6305
文章目录一、前言二、概述三、负载均衡算法轮询（Round Robin）法随机（Random）法加权轮询（Weight Round Robin）法加权随机（Weight Random）法最小连接数（Least Connections）法 一、前言         最近在开发聊天室服务器，考虑到服务器的并发性，因此需要支持聊天服务器的集群功能。对服务器需要做负载均衡，查阅了一些资料，在此做下简单总结和笔记。 二、概述  &
5大负载均衡算法 (原理图解)
「 虚幻私塾」
10-25 669
陈睿 |mikechen, 10年+大厂架构经验,「mikechen 的互联网架构」系列文章作者，专注互联网架构技术。👇「mikechen 的互联网架构」的更多技术文章合集👇Java并发|JVM|MySQL|Spring|Redis|分布式|高并发。
负载均衡的算法
qfikh的博客
10-07 1463
1、轮询法 　　将请求按顺序轮流地分配到后端服务器上，它均衡地对待后端的每一台服务器，而不关心服务器实际的连接数和当前的系统负载。 2、随机法      通过系统的随机算法，根据后端服务器的列表大小值来随机选取其中的一台服务器进行访问。由概率统计理论可以得知，随着客户端调用服务端的次数增多， 其实际效果越来越接近于平均分配调用量到后端的每一台服务器，也就是轮询的结果。 3、源地址哈希法
Java中的负载均衡策略详解
微赚淘客系统开发者博客
07-24 1208
了解并实现不同的负载均衡策略（如轮询、最少连接数、加权轮询和随机）以及利用Java中的负载均衡框架和工具（如Spring Cloud、Nginx和HAProxy），可以帮助你构建高性能、可靠的分布式系统。负载均衡是提高系统可用性、扩展性和性能的重要技术，它通过将流量或请求分配到多个服务器上，以避免单点故障和提高系统的处理能力。本文将介绍负载均衡的基本概念、常见的负载均衡策略、在Java中实现这些策略的方式，以及如何使用相关的框架和工具。加权轮询策略在轮询的基础上，给予不同的服务器不同的权重。
负载均衡的基本算法
weixin_33894992的博客
11-09 150
负载均衡的基本算法，主要有以下几种（参考F5产品）： 随机：负载均衡方法随机的把负载分配到各个可用的服务器上，通过随机数生成算法选取一个服务器，然后把连接发送给它。虽然许多均衡产品都支持该算法，但是它的有效性一直受到质疑，除非把服务器的可运行时间看的很重。 轮询：轮询算法按顺序把每个新的连接请求分配给下一个服务器，最终把所有请求平分给所有的服务器。轮询算法在大多数情况下都工作的不错，但是如...
负载均衡原理及算法解析
05-11
基于IP哈希的负载均衡算法是一种特殊类型，它将请求根据客户端IP地址的哈希值分配到特定的服务器上。这种算法保证了来自同一个客户端的所有请求都会被发送到相同的服务器上，有助于维持会话的一致性和状态管理。例如...
Robin六种常用负载均衡算法源码解析
m0_46330591的博客
02-28 1178
1 经典轮询算法 在这里插入代码片 //Robin的负载均衡原理为 请求服务=请求次数%服务个数。 //请求计数器 private AtomicInteger nextServerCyclicCounter; public Server choose(ILoadBalancer lb, Object key) { if (lb == null) { log.warn("no load balancer"); return null;
二、负载均衡与反向代理——负载均衡算法
最新发布
流楚丶格念的博客
08-19 568
一致性哈希算法基于请求的某个属性（如 URI 或参数）计算哈希值，将请求分配到上游服务器。这样可以保持会话的一致性，使得来自同一 IP 的请求始终被转发到相同的上游服务器。权重较高的服务器会接收到更多的请求，同时也会根据连接数的情况来调整。请求将根据服务器的权重值进行分配，高权重的服务器会接收到更多的请求。哈希算法通过对请求的某个属性（如 URI 或请求参数）进行哈希，将请求分发到上游服务器。通过选择合适的负载均衡算法，可以根据实际业务需求和服务器性能优化请求的分发，提高系统的整体性能和用户体验。
负载均衡原理/种类/算法
Kim_Weir的专栏
06-02 610
一.    负载均衡原理   系统的扩展可分为纵向（垂直）扩展和横向（水平）扩展。纵向扩展，是从单机的角度通过增加硬件处理能力，比如CPU处理能力，内存容量，磁盘等方面，实现服务器处理能力的提升，不能满足大型分布式系统（网站），大流量，高并发，海量数据的问题。因此需要采用横向扩展的方式，通过添加机器来满足大型网站服务的处理能力。比如：一台机器不能满足，则增加两台或者多台机器，共同承担访问压力。这就...
负载均衡算法原理解析（二）
zqhao的博客
01-24 351
上一篇文章中讲解了加权随机和加权轮询算法，本文主要讲解剩余的两个，一致性哈希和最小活跃数算法的实现思想。 一致性哈希-ConsistentHashLoadBalance 服务器集群接收到一次请求调用时，可以根据请求的信息，比如客户端的IP地址、请求路径、请求参数等信息进行哈希，得到一个哈希值，特点是相对于相同的请求信息（ip地址，或请求路径和请求参数）哈希出来的值是一样的，只要能再增加一个算法，将...
负载均衡算法大全
weixin_30951743的博客
07-13 113
负载均衡的发展基础就是负载均衡算法。那么针对不同的服务器我们也会采用不同的负载均衡算法，因为他们所具备的和要求的功能各不相同。那么我们现在就来详细了解一下这方面的知识。希望能让大家从中得到需要的东西。服务器负载均衡算法有很多(持续性的和非持续性的),包括轮循算法､最少连接算法､响应时间算法､散列算法､最少连接失误算法,链路带宽算法等等｡此外实际服务器(RealServer)可以被分配不同的加权值来...
SpringCloud Ribbon：负载均衡算法详解与源码解析
本文主要介绍了SpringCloud中的Ribbon负载均衡算法。首先回顾了SpringCloud的基本概念，包括版本选型、工程构建以及与Eureka、Consul等注册中心的集成。其中，Eureka是SpringCloud的核心组件，作为服务发现工具，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值