聊聊六种负载均衡算法

负载均衡（Load Balancing）是一种计算机网络和服务器管理技术，旨在分配网络流量、请求或工作负载到多个服务器或资源，以确保这些服务器能够高效、均匀地处理负载，并且能够提供更高的性能、可用性和可扩展性。
这篇文章，我们聊聊六种通用的负载均衡算法。

1 轮询 (Round Robin)

轮询是指将请求按顺序轮流地分配到后端服务器上，它均衡地对待后端的每一台服务器，而不关心服务器实际的连接数和当前的系统负载。

示例代码：

1. import java.util.List;
2. import java.util.concurrent.atomic.AtomicInteger;
4. public class RoundRobin {
5.     private final List<String> servers;
6.     private final AtomicInteger index = new AtomicInteger(0);
8.     public RoundRobin(List<String> servers) {
9.         this.servers = servers;
10.     }
12.     public String getServer() {
13.         int currentIndex = index.getAndIncrement() % servers.size();
14.         return servers.get(currentIndex);
15.     }
16. }

复制代码

2 粘性轮询 (Sticky Round-Robin)

粘性轮询是标准轮询算法的一个变种，它通过记住客户端与服务实例的映射关系，确保来自同一客户端的连续请求会被路由到同一个服务实例上。
它的特点是：

• 会话保持：一旦客户端首次请求被分配到某个服务实例，后续请求会"粘"在这个实例上
  
• 客户端识别：通常基于客户端IP、会话ID或特定HTTP头来识别客户端
  
• 故障转移：当目标服务实例不可用时，系统会重新分配客户端到其他可用实例
  

示例代码：

1. import java.util.List;
2. import java.util.Map;
3. import java.util.concurrent.ConcurrentHashMap;
4. import java.util.concurrent.atomic.AtomicInteger;
6. public class StickyRoundRobin {
7.     private final List<String> servers;
8.     private final AtomicInteger index = new AtomicInteger(0);
9.     private final Map<String, String> clientToServer = new ConcurrentHashMap<>();
11.     public StickyRoundRobin(List<String> servers) {
12.         this.servers = servers;
13.     }
15.     public String getServer(String clientId) {
16.         return clientToServer.computeIfAbsent(clientId,
17.             k -> servers.get(index.getAndIncrement() % servers.size()));
18.     }
19. }

复制代码

3 加权轮询 (Weighted Round-Robin)

加权轮询是标准轮询算法的增强版本，它允许管理员为每个服务实例分配不同的权重值。权重越高的实例处理越多的请求，从而实现更精细的负载分配。

它的特点是:

• 权重分配：每个服务实例都有对应的权重值
  
• 比例分配：请求按权重比例分配到不同实例
  
• 动态调整：权重可以动态修改以适应不同场景
  

示例代码：

1. private static Map<String, Integer> serverMap = new ConcurrentHashMap<>();
2. //记录服务器权重总和
3. private static int totalWeight = 0;
5. public static String weightRandom() {
6.     //获取服务器数量
7.     int serverCount = serverMap.size();
8.     //如果没有可用的服务器返回null
9.     if (serverCount == 0) {
10.         return null;
11.     }
12.     //在此处为避免多线程并发操作造成错误，在方法内部进行锁操作
13.     synchronized (serverMap) {
14.         //计算服务器权重总和
15.         for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
16.             totalWeight += entry.getValue();
17.         }
18.         //生成一个随机数
19.         int randomWeight = new Random().nextInt(totalWeight);
20.         //遍历服务器列表，根据服务器权重值选择对应地址
21.         for (Map.Entry<String, Integer> entry : serverMap.entrySet()) {
22.             String serverAddress = entry.getKey();
23.             Integer weight = entry.getValue();
24.             randomWeight -= weight;
25.             if (randomWeight < 0) {
26.                 return serverAddress;
27.             }
28.         }
29.     }
30.     //默认返回null
31.     return null;
32. }
34. public class WeightRandomLoadBalancer implements LoadBalancer {
35.     private List<String> servers = new ArrayList<>();
36.     private Map<String, Integer> weightMap = new HashMap<>();
38.     public WeightRandomLoadBalancer(Map<String, Integer> servers) {
39.         this.servers.addAll(servers.keySet());
40.         for (String server : servers.keySet()) {
41.             int weight = servers.get(server);
42.             weightMap.put(server, weight);
43.         }
44.     }
45.     @Override
46.     public String chooseServer() {
47.         int weightSum = weightMap.values().stream().reduce(Integer::sum).orElse(0);
48.         int randomWeight = ThreadLocalRandom.current().nextInt(weightSum) + 1;
49.         for (String server : servers) {
50.             int weight = weightMap.get(server);
51.             if (randomWeight <= weight) {
52.                 return server;
53.             }
54.             randomWeight -= weight;
55.         }
56.         return null;
57.     }
58. }

复制代码

6 最快响应时间 (Least Response Time)

最快响应时间（Least Response Time，LRT）是一种智能动态负载均衡算法，它通过选择当前响应时间最短的服务器来处理新请求，从而优化整体系统性能。

LRT 算法基于以下核心判断标准：

• 实时性能监控：持续跟踪每台服务器的历史响应时间
  
• 动态路由决策：新请求总是分配给响应最快的可用服务器
  
• 自适应学习：根据服务器性能变化自动调整流量分配
  

示例代码：

1. import java.util.List;
2. import java.util.zip.CRC32;
4. public class SourceIPHashLoadBalancer {
5.     private final List<String> servers;
6.    
7.     public SourceIPHashLoadBalancer(List<String> servers) {
8.         this.servers = servers;
9.     }
10.    
11.     public String getServer(String clientIP) {
12.         if (servers.isEmpty()) {
13.             return null;
14.         }
15.         
16.         // 计算IP的哈希值
17.         long hash = calculateHash(clientIP);
18.         
19.         // 取模确定服务器索引
20.         int index = (int) (hash % servers.size());
21.         
22.         return servers.get(Math.abs(index));
23.     }
24.    
25.     private long calculateHash(String ip) {
26.         CRC32 crc32 = new CRC32();
27.         crc32.update(ip.getBytes());
28.         return crc32.getValue();
29.     }
30. }

复制代码

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除