当前位置：首页 > news >正文

解密面试高频题：加权轮询负载均衡算法 (Java 实现)

news 来源：原创 2025/4/29 14:12:37

在分布式系统设计和面试中，负载均衡是一个绕不开的话题。而加权轮询（Weighted Round Robin, WRR）作为一种经典且实用的负载均衡策略，经常出现在笔试题和面试环节中。本文将带你深入理解 WRR 算法的原理，并探讨几种常见的 Java 实现方式及其优缺点，助你轻松应对相关考题。

什么是加权轮询 (WRR)？

想象一下，你有几台服务器，但它们的处理能力（CPU、内存等）不一样。你希望性能强的服务器能多处理一些请求，性能弱的少处理一些，同时还要保证所有服务器都有机会处理请求，避免“旱的旱死，涝的涝死”。

加权轮询就是为了解决这个问题。它允许我们为每台服务器设置一个“权重”（Weight），权重越高的服务器，在一段时间内被分配到的请求比例就越高。

核心思想：按服务器权重比例，周期性地、有序地将请求分配给服务器。

WRR 算法基本流程

根据你提供的资料，其基本概念可以概括为：

分配权重：为每个服务器分配一个初始权重（整数）。这个权重通常基于服务器的性能、配置等因素。权重越高，预期处理的请求越多。
选择服务器：当有新请求到来时，算法会根据某种规则（后面会详细讲）选择一台服务器来处理。
调整状态：被选中的服务器处理请求后，其内部状态（可能是权重或某个计数值）会进行调整，以影响下一次被选中的概率。
周期性重置/循环：当所有服务器的状态达到某个条件（例如，所有服务器的临时权重都减为 0，或者完成一个完整的轮询周期），状态可能会重置或进入下一个循环，重新开始分配。

优点：

简单易懂：逻辑相对清晰。
按能力分配：能根据预设的服务器处理能力（权重）进行请求分发。
无状态：基本的 WRR 不需要记录会话信息，实现简单。

缺点：

静态权重：传统 WRR 无法根据服务器的实时负载（如 CPU 使用率、当前连接数）动态调整。如果某台高权重服务器突然负载过高，WRR 仍然会按权重给它分配请求。
可能不平滑：简单的实现可能导致请求在短时间内集中发送给高权重服务器，造成瞬时压力。

Java 实现方法探讨

下面我们来看几种 Java 实现 WRR 的思路，从简单到优化。

方法一：简单列表扩展法 (WeightedRoundRobinSimple 改进版)

这是最直观的一种想法：如果服务器 A 权重为 3，服务器 B 权重为 1，那我就创建一个包含 [A, A, A, B] 的列表，然后对这个列表进行普通的轮询（Round Robin）。

实现思路：

初始化：在类加载时（或首次使用时），根据服务器 IP 和对应的权重，构建一个扩展列表。例如，{"A": 3, "B": 1} 会扩展成 ["A", "A", "A", "B"] （顺序可以不同，但数量要对）。
选择节点：维护一个全局（或实例）的索引 index。每次请求时：
- 获取 nodes.get(index)。
- index = (index + 1) % nodes.size()。
- 注意线程安全：如果是多线程环境，对 index 的读写需要加锁。

代码示例 (基于你改进后的 WeightedRoundRobinSimple.java)：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;public class WeightedRoundRobinSimple {private static Integer index = 0;private static Map<String,Integer> mapNodes = new HashMap<>();// 扩展后的服务器列表，只计算一次private static final List<String> nodes = new ArrayList<>();static {// 模拟服务器和权重mapNodes.put("192.168.1.101", 1); // 权重 1mapNodes.put("192.168.1.102", 3); // 权重 3mapNodes.put("192.168.1.103", 2); // 权重 2// 预计算扩展列表Iterator<Map.Entry<String, Integer>> iterator = mapNodes.entrySet().iterator();while (iterator.hasNext()){Map.Entry<String, Integer> entry = iterator.next();String key = entry.getKey();for (int i = 0; i < entry.getValue(); i++){nodes.add(key); // 添加 'weight' 次}}// 结果可能是 [101, 102, 102, 102, 103, 103] (顺序取决于 Map 迭代顺序)System.out.println("预计算的服务器列表：" + nodes);}public String selectNode(){if (nodes.isEmpty()) {return null;}String selectedNode = null;synchronized (WeightedRoundRobinSimple.class) { // 使用类锁保证线程安全if(index >= nodes.size()) {index = 0; // 到达列表末尾，重置索引}selectedNode = nodes.get(index);index++;}return selectedNode;}// main 方法用于测试 (省略，与你提供的一致)
}

评价：

优点：实现简单，逻辑清晰，易于理解。改进后（预计算列表）性能比每次调用都重新生成列表要好得多。
缺点：
- 内存消耗：如果服务器权重非常大（比如几千甚至上万），扩展后的列表会占用大量内存。
- 不够平滑：在一个周期内，权重高的服务器会被连续选中多次，可能导致请求不够分散。例如 [A, A, A, B]，前三次请求都会给 A。

方法二：平滑加权轮询 (Smooth Weighted Round Robin - 类似 Nginx)

为了解决简单扩展法不够平滑和内存占用的问题，出现了一种更优化的算法，常被称为“平滑加权轮询”，Nginx 的 WRR 实现就采用了类似的思想。

核心思想：

每个服务器维护两个权重：

weight: 固定的原始权重，初始化时设定。
currentWeight: 当前动态权重，初始为 0 或 weight。

算法步骤 (基于你提供的 WeightedRoundRobin 类和图片逻辑)：

初始化：所有服务器的 currentWeight 初始化为 0（或者等于其 weight，不同实现略有差异，我们以你给的 WeightedRoundRobin 为例，它似乎是隐式从 weight 开始的，但 Nginx 原始算法通常从 0 开始）。计算所有服务器的权重之和 totalWeight。
每次选择时：
a. 遍历所有服务器，将每个服务器的 currentWeight 增加其对应的 weight 值。 (server.currentWeight += server.weight)
b. 从所有服务器中，找到 currentWeight 最大的那个服务器，它就是本次要选中的服务器。
c. 将选中的服务器的 currentWeight 减去 totalWeight。 (selectedServer.currentWeight -= totalWeight)
返回选中的服务器。

为什么这样能工作？

currentWeight 可以理解为服务器“等待”处理请求的“潜力值”或“优先级”。
每次选择前，所有服务器的潜力都根据其自身能力（weight）增长。
选择潜力最高的服务器，意味着优先选择等待最久或能力最强的。
选中后将其潜力减去 totalWeight，是为了平衡，防止它连续被选中，相当于它消耗了本次机会，需要重新积累潜力，给其他服务器机会。这个过程保证了请求分布相对平滑。

代码示例 (基于你提供的 WeightedRoundRobin.java):

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;public class WeightedRoundRobin {// 内部 Node 类表示服务器public static class Node { // 设为 static 方便外部访问或保持原样内部类private String serverName;private final Integer weight;       // 固定权重private Integer currentWeight; // 当前权重public Node(String serverName, Integer weight) {this.serverName = serverName;this.weight = weight;this.currentWeight = 0; // Nginx 风格通常初始化为 0// 你的例子似乎是隐式等于 weight 开始? 统一按 0 开始演示}// Getters and Setters... (省略)public String getServerName() { return serverName; }public Integer getWeight() { return weight; }public Integer getCurrentWeight() { return currentWeight; }public void setCurrentWeight(Integer currentWeight) { this.currentWeight = currentWeight; }}private final List<Node> servers;private final int totalWeight;public WeightedRoundRobin(List<Node> servers) {this.servers = servers;// 计算总权重this.totalWeight = servers.stream().mapToInt(Node::getWeight).sum();// 初始化 currentWeight (如果需要的话，这里设为0)// this.servers.forEach(s -> s.setCurrentWeight(0)); // 显式初始化为 0}// 注意：这个方法需要是线程安全的，如果实例被多线程共享public synchronized String getServer() { // 添加 synchronized 保证线程安全if (servers.isEmpty()) {return null;}// 1. 所有 currentWeight += weightfor (Node server : servers) {server.setCurrentWeight(server.getCurrentWeight() + server.getWeight());}// 2. 找到 currentWeight 最大的服务器Node bestServer = servers.stream().max(Comparator.comparingInt(Node::getCurrentWeight)).orElse(null); // 处理空列表情况if (bestServer == null) return null;// 3. 选中的服务器 currentWeight -= totalWeightbestServer.setCurrentWeight(bestServer.getCurrentWeight() - totalWeight);return bestServer.getServerName();}public static void main(String[] args) {// 初始化服务器列表List<Node> serverNodes = 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));WeightedRoundRobin roundRobin = new WeightedRoundRobin(serverNodes);// 模拟请求分发 (总权重 1+2+3+4 = 10)System.out.println("平滑加权轮询测试:");for (int i = 0; i < 10; i++) { // 进行一个总权重周期的测试String server = roundRobin.getServer();System.out.println("请求 " + (i + 1) + " 发送到: " + server);// 打印当前权重状态，方便理解System.out.print("  当前权重状态: ");serverNodes.forEach(n -> System.out.print(n.getServerName() + "={" + n.getCurrentWeight() + "} "));System.out.println();}}
}

评价：

优点：
- 平滑性好：请求分布更均匀，避免对高权重服务器的瞬时冲击。
- 内存高效：不需要存储庞大的扩展列表。
缺点：
- 逻辑稍复杂：相对于简单扩展法，理解起来需要多花一点时间。
- 计算开销：每次请求都需要遍历所有服务器进行计算和比较。但在服务器数量不是极其庞大的情况下，这点开销通常可以接受。

面试中如何选择？

如果时间紧迫或题目要求简单实现：可以先写出改进后的简单列表扩展法，并向面试官说明其优缺点（特别是内存问题和不够平滑）。这表明你理解了基础概念。
如果追求更优解或有充足时间：平滑加权轮询算法是更推荐的答案。它能体现你对负载均衡算法更深入的理解和优化能力。写出这个版本通常会是加分项。
务必考虑线程安全：无论哪种方法，只要负载均衡器实例可能被多个线程并发访问，就必须确保 getServer() 或 selectNode() 方法是线程安全的（通常通过 synchronized 关键字或使用并发集合/原子类等）。