一般来说，我们在设计系统的时候，为了系统的高扩展性，会尽可能的把系统创建成无状态的，这样我们就可以集群的方式部署，这样我们就可以很方便的根据情况动态增加或者减少服务器的数量。但是，要使系统具有更好的可扩展性，除了无状态设计之外，关键考虑的是负载均衡算法。
什么是负载均衡
负载均衡是指多台服务器以对称的方式组成一个服务器集群。每台服务器具有同等地位（但不同的服务器可能有不同的性能），可以独立提供服务，无需其他服务器的协助。为了保证系统的可扩展性，需要有一种算法可以将系统负载平均分配到集群中的每台服务器上。这种算法称为负载均衡算法。负责执行负载均衡算法并平均分配请求的服务器称为负载均衡器。
随机算法
随机算法非常简单。该算法的核心是通过随机函数随机获取一个服务器进行访问。假设我们现在有四台服务器，192.168.1.1~ 192.168.1.4。该算法实现如下。
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，以此类推。我们可以看到轮询算法可以在集群中平均分配请求。但是，该算法与随机算法有同样的缺点。如果服务器性能不同，负载将不均衡，所以需要加权轮询算法。
加权循环
加权轮询是在轮询的基础上，根据服务器的性能来分配权重。服务器可以支持的请求越多，权重就越高，分配的请求就越多。对于同样的 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代表服务器数量。该算法的优点是实现起来非常简单。具体实现如下：
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(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);
}
}
hash算法在很多缓存分布式存储系统中很常见，比如Memorycached以及Redis，但是上面的hash算法一般不会用到，而是优化的一致性hash算法（本文就不介绍了。有兴趣的我会单独写一个一致性哈希算法介绍），因为上述哈希算法对于缓存系统有一个致命的缺点。如果服务器增加或减少，大量缓存不会被命中。
介绍完四种负载均衡算法后，希望这篇文章能让大家对负载均衡策略有更深入的了解。感谢您的阅读。
