场景面试题--RPC 负载均衡：当服务节点 “能力不一” 时该如何分流？

最新推荐文章于 2026-01-08 00:03:47 发布

原创最新推荐文章于 2026-01-08 00:03:47 发布 · 1k 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#rpc #负载均衡 #网络协议 #学习 #java #分布式

RPC(Java) 专栏收录该内容

8 篇文章

订阅专栏

在 RPC 集群中，我们通常假设所有服务节点的性能一致，因此用轮询、随机等均衡策略分发流量。但实际场景中，节点的承压能力可能差异很大（如有的节点是 8 核 CPU，有的是 4 核）。如果继续 “平均分配”，弱节点会先被压垮，导致整个集群性能下降。这时，基于节点能力动态调整流量的负载均衡策略就成了关键。

一、核心问题：为什么 “平均分配” 会出问题？

假设有一个 RPC 服务集群，包含 3 个节点：

节点 A：高性能服务器，每秒可处理 1000 请求；
节点 B：普通服务器，每秒可处理 500 请求；
节点 C：低配服务器，每秒可处理 300 请求。

若用轮询策略（每个节点轮流接收请求），当总 QPS 达到 1800 时：

节点 A：处理 600 请求（远低于上限，资源浪费）；
节点 B：处理 600 请求（超过上限 100，开始卡顿）；
节点 C：处理 600 请求（超过上限 300，直接崩溃）。

结论：不考虑节点能力的负载均衡，会导致 “强者空闲、弱者崩溃”。

二、解决方案：用 “虚拟节点权重” 实现能力匹配

一致性哈希算法的 “虚拟节点” 机制，天然适合解决这个问题 —— 通过给强节点分配更多虚拟节点，让其承担更多流量。

1. 原理：虚拟节点数量 = 节点能力权重

核心逻辑：节点性能越强，分配的虚拟节点数量越多，在哈希环上占据的 “位置” 越密集，被选中的概率越高。
示例：
- 节点 A（1000QPS）：分配 10 个虚拟节点；
- 节点 B（500QPS）：分配 5 个虚拟节点；
- 节点 C（300QPS）：分配 3 个虚拟节点。
  此时流量比例约为 10:5:3，与节点能力匹配。

2. 实现步骤：从注册中心到客户端负载均衡

（1）服务端：注册节点能力信息

服务节点启动时，向注册中心（如 ZooKeeper、Nacos）注册自身的 “性能权重”（可通过 CPU 核心数、内存大小自动计算，或手动配置）。

// 服务端注册信息示例
public class ServerRegistryInfo {
    private String host;
    private int port;
    private int weight; // 权重：越高表示能力越强

    // 构造函数：根据CPU核心数计算权重（示例）
    public ServerRegistryInfo(String host, int port) {
        this.host = host;
        this.port = port;
        this.weight = Runtime.getRuntime().availableProcessors() * 2; // 8核CPU权重为16
    }
}

（2）客户端：根据权重生成虚拟节点

客户端从注册中心获取所有节点的权重信息，在构建一致性哈希环时，按权重分配虚拟节点数量。

public class WeightedConsistentHash {
    private final SortedMap<Integer, String> circle = new TreeMap<>(); // 哈希环
    private final int virtualNodeBase = 10; // 基础虚拟节点数（权重1对应10个虚拟节点）

    // 初始化哈希环：按权重分配虚拟节点
    public void init(List<ServerRegistryInfo> servers) {
        for (ServerRegistryInfo server : servers) {
            String nodeKey = server.getHost() + ":" + server.getPort();
            int virtualNodeCount = server.getWeight() * virtualNodeBase;

            // 添加虚拟节点到哈希环
            for (int i = 0; i < virtualNodeCount; i++) {
                String virtualNodeKey = nodeKey + "&&vn" + i;
                int hash = hash(virtualNodeKey);
                circle.put(hash, nodeKey);
            }
        }
    }

    // 路由逻辑：根据请求key找到对应的节点
    public String route(String requestKey) {
        int hash = hash(requestKey);
        // 找到环上大于等于当前哈希值的节点
        SortedMap<Integer, String> subMap = circle.tailMap(hash);
        String nodeKey;
        if (subMap.isEmpty()) {
            // 从头开始
            nodeKey = circle.get(circle.firstKey());
        } else {
            nodeKey = subMap.get(subMap.firstKey());
        }
        return nodeKey;
    }

    private int hash(String key) {
        return Math.abs(key.hashCode() % 359); // 简化的哈希计算
    }
}