每个Java程序员都必须知道的四种负载均衡算法

前言

欢迎关注个人公众号『JAVA旭阳』交流沟通

什么是负载均衡

随机算法

随机算法非常简单，该算法的核心是通过随机函数随机获取一个服务器进行访问。假设我们现在有四台服务器，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需要减去所有服务器的权重之和，这样可以避免权重高的服务器一直被选中。权重高的服务器有更多的分配请求，请求可以平均分配给所有服务器。

哈希算法

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，但是一般不会用到上面的哈希算法，而是优化后的一致性哈希算法。

总结

nginx或者spring cloud中的ribbon都使用到了这样的算法思想，我们可以根据自己的业务场景选择合适算法。