四个Java必须知道的负载均衡算法分享

更新时间：2023年01月10日 10:05:19 作者：JAVA旭阳

我们在设计系统的时候，为了系统的高扩展性，会创建无状态的系统。但是，要使系统具有更好的可扩展性，除了无状态设计之外，还要考虑采用什么负载均衡算法，本文就带领大家认识以下常见的4种负载均衡算法

前言

一般来说，我们在设计系统的时候，为了系统的高扩展性，会尽可能的创建无状态的系统，这样我们就可以采用集群的方式部署，最终很方便的根据需要动态增减服务器数量。但是，要使系统具有更好的可扩展性，除了无状态设计之外，还要考虑采用什么负载均衡算法，本文就带领大家认识以下常见的4种负载均衡算法。

什么是负载均衡

负载均衡是指多台服务器以对称的方式组成一个服务器集群。每台服务器的地位相当（但不同的服务器可能性能不同），可以独立提供服务，无需其他服务器的辅助。为了保证系统的可扩展性，需要有一种算法能够将系统负载平均分配给集群中的每台服务器。这种算法称为负载均衡算法。负责执行负载均衡算法并平均分配请求的服务器称为负载均衡器。

随机算法

随机算法非常简单，该算法的核心是通过随机函数随机获取一个服务器进行访问。假设我们现在有四台服务器，192.168.1.1~ 192.168.1.4, 该算法用java实现大致如下：

public class RandomTest {

    private static final List<String> servers = Arrays.asList("192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4");

    public static String getServer() {
        Random random = new Random();
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }


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

当样本较小时，算法可能分布不均匀，但根据概率论，样本越大，负载会越均匀，而负载均衡算法本来就是为应对高并发场景而设计的。该算法的另一个缺点是所有机器都有相同的访问概率, 如果服务器性能不同，负载将不平衡。

轮询算法

Round-Robin轮询算法是另一种经典的负载均衡算法。请求以循环的方式分发到集群中的所有服务器。同理，对于上述四台服务器，假设客户端向集群发送10个请求，则请求分布将如下图所示：

在十个请求中，第一、第五和第九个请求将分配给192.168.1.1，第二、第六和第十个请求将分配给192.168.1.2，依此类推。我们可以看到round-robin算法可以在集群中均匀的分配请求。但是，该算法具有与随机算法相同的缺点，如果服务器性能不同，负载将不平衡，因此需要加权轮询算法。

加权轮询算法

Weighted Round-Robin加权轮询算法是在round-robin算法的基础上根据服务器的性能分配权重。服务器能支持的请求越多，权重就越高，分配的请求也就越多。对于同样的10个请求，使用加权轮询算法的请求分布会如下图所示：

可以看到192.168.1.4权重最大，分配的请求数最多。看一下使用Java简单实现的以下加权循环算法。

public class RoundRobinTest {

    public class Node{
        private String ip;

        private Integer weight;

        private Integer currentWeight;

        public Node(String ip,Integer weight) {
            this.ip = ip;
            this.weight = weight;
            this.currentWeight = weight;
        }

        public String getIp() {
            return ip;
        }

        public void setIp(String ip) {
            this.ip = ip;
        }

        public Integer getWeight() {
            return weight;
        }

        public void setWeight(Integer weight) {
            this.weight = weight;
        }

        public Integer getCurrentWeight() {
            return currentWeight;
        }

        public void setCurrentWeight(Integer currentWeight) {
            this.currentWeight = currentWeight;
        }
    }

    List<Node> servers = Arrays.asList(
            new Node("192.168.1.1",1),
            new Node("192.168.1.2",2),
            new Node("192.168.1.3",3),
            new Node("192.168.1.4",4));
    private Integer totalWeight;

    public RoundRobinTest() {
        this.totalWeight = servers.stream()
                .mapToInt(Node::getWeight)
                .reduce((a,b)->a+b).getAsInt();
    }


    public String getServer() {
        Node node = servers.stream().max(Comparator.comparingInt(Node::getCurrentWeight)).get();
        node.setCurrentWeight(node.getCurrentWeight()-totalWeight);
        servers.forEach(server->server.setCurrentWeight(server.getCurrentWeight()+server.getWeight()));
        return node.getIp();
    }


    public static void main(String[] args) {
        RoundRobinTest roundRobinTest = new RoundRobinTest();
        for (int i = 0; i < 10; i++) {
            String server = roundRobinTest.getServer();
            System.out.println("select server: "+server);
        }
    }

该算法的核心是的动态计算currentWeight。每个服务器被选中后，currentWeight需要减去所有服务器的权重之和，这样可以避免权重高的服务器一直被选中。权重高的服务器有更多的分配请求，请求可以平均分配给所有服务器。

哈希算法

哈希算法，顾名思义，就是利用哈希表根据计算出请求的路由hashcode%N。这里hashcode代表哈希值，N代表服务器数量。该算法的优点是实现起来非常简单。具体实现如下：

rivate static final List<String> servers = Arrays.asList("192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4");

    public static String getServer(String key) {
        int hash = key.hashCode();
        int index =  hash%servers.size();
        return servers.get(index);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            String server = getServer(String.valueOf(i));
            System.out.println("select server: "+server);
        }
    }

哈希算法在很多缓存分布式存储系统中很常见，比如Memorycached和Redis，但是一般不会用到上面的哈希算法，而是优化后的一致性哈希算法。

总结

本文总结了负载均衡常见的4种算法，我们可以发现nginx或者spring cloud中的ribbon都使用到了这样的算法思想，我们可以根据自己的业务场景选择合适算法。

到此这篇关于四个Java必须知道的负载均衡算法分享的文章就介绍到这了,更多相关Java负载均衡算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java Arrays.sort()用法详解
这篇文章主要介绍了Java Arrays.sort()用法详解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
2021-08-08
Java 对 Cookie增删改查的实现示例
这篇文章主要介绍了Java 对 Cookie增删改查的实现示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-05-05
Mybatis-plus原生pages分页未生效的解决方案
本文主要介绍了Mybatis-plus原生pages分页未生效的解决方案,包含介绍了未生效的5种原因以及解决方法,具有一定的参考价值,感兴趣的可以了解一下
2024-07-07
将idea中xml文件背景颜色去除的图文教程
这篇文章主要介绍了将idea中xml文件背景颜色去除，本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2020-07-07
浅谈Java设计模式之开放封闭原则
本篇文章主要介绍了浅谈Java设计模式之开放封闭原则，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-03-03
Spring通过配置文件管理Bean对象的方法
这篇文章主要介绍了Spring通过配置文件管理Bean对象的相关知识，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2022-07-07
对SpringMVC的@RequestParam的解释
下面小编就为大家带来一篇对SpringMVC的@RequestParam的解释。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-09-09
java向mysql插入数据乱码问题的解决方法
这篇文章主要为大家详细介绍了java向mysql插入数据乱码问题的解决方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-09-09
Spring5中SpringWebContext方法过时的解决方案
这篇文章主要介绍了Spring5中SpringWebContext方法过时的解决方案，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-01-01
Java实现通过时间获取8位验证码
这篇文章主要为大家详细介绍了Java如何通过时间获取8位验证码（每两个小时生成一个）,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
2023-11-11