# 一、负载均衡

30 秒速记

  • 负载均衡器 = 集群的统一入口:先用算法挑一个节点,再把请求转过去
  • 前提是应用节点无状态,会话放 Redis 这类共享存储,或者由客户端带着(JWT)
  • 带来两样东西:高可用(坏一台摘掉,流量转给别的)+ 伸缩性(加机器就加进节点池)
  • 靠健康检查维护可用节点列表;新节点要预热,下线节点要先排空连接
  • 负载均衡器自己也是单点,要做主备或多实例(比如 Keepalived + VIP)

负载均衡就是在一堆机器前面放个「分配员」,每个请求来了由它挑一台机器处理。 它能成立的前提是后面的机器无状态,同一个用户这次打到 A、下次打到 B 都没问题,所以登录态不能只放在某台机器的内存里。好处有两个:一台挂了健康检查把它摘掉,用户无感;流量大了往池子里加机器就行。挑哪台由算法决定,轮询、加权、最少连接、IP Hash 各有适用场景。别忘了负载均衡器本身也可能挂,生产上一般是主备加虚拟 IP。

集群中的应用服务器(节点)通常被设计成无状态,用户可以请求任何一个节点。

负载均衡器会根据集群中每个节点的负载情况,将用户请求转发到合适的节点上。

负载均衡器可以用来实现高可用以及伸缩性:

  • 高可用:当某个节点故障时,负载均衡器会将用户请求转发到另外的节点上,从而保证所有服务持续可用;
  • 伸缩性:根据系统整体负载情况,可以很容易地添加或移除节点。

负载均衡器运行过程包含两个部分:

  1. 根据负载均衡算法得到转发的节点;
  2. 进行转发。

# 负载均衡算法

原理拆解: 请求先到达负载均衡器,负载均衡算法从当前可用节点集合中选出目标,再由转发层把请求送到该节点。无状态并不是“服务器没有任何数据”,而是处理一次请求所需的会话状态不独占在某台应用节点上;状态可由客户端携带,或存入共享数据库、缓存等外部系统。这样同一用户的后续请求才能安全落到其他健康节点。

具体实现: 轮询适合处理能力接近、请求成本相近的节点;加权轮询可让配置更高的节点承担更多流量;最少连接更关注当前并发占用。负载均衡器通常结合健康检查维护可选节点集合:节点连续探测失败后暂时摘除,恢复并通过检查后再加入。扩容时把新节点注册进节点池,缩容时应先停止分配新请求,并给已有连接留出排空时间。

边界与反例: 如果登录会话只保存在某台节点的内存中,普通轮询可能让下一次请求丢失会话;可以迁移到共享存储,也可以使用会话亲和,但后者会削弱流量均匀性和故障切换能力。算法看到的连接数也不等同于真实计算压力,长连接、慢请求和高成本任务都可能造成偏差。负载均衡器作为统一入口仍可能成为瓶颈或单点,入口自身的冗余与故障转移需要另行设计。

工程验证: 给每个节点的响应加入唯一实例标识,在并发压测中统计请求分布、延迟和错误率;随后停止一个节点,确认健康检查窗口结束后不再出现该标识,并观察失败请求是否符合预期。扩缩容验证还应检查新节点预热、连接排空、超时、重试上限和幂等性,避免一次后端故障被无界重试放大成集群级流量峰值。

面试官追问

追问 1登录态存在各节点内存里,直接上轮询会怎样?
参考回答

用户登录后下一个请求打到别的节点,就变成未登录了。正解是把 Session 放 Redis,或者改用 JWT;临时救急可以开会话保持,但它会让流量不均、节点挂了照样掉登录。

追问 2大促前加了三台机器,注册进节点池就能直接扛流量吗?
参考回答

别急着全量。新节点要先过健康检查,JVM 这类有预热过程的服务最好慢启动,逐步加权重,不然冷启动那几秒就是一波超时。

追问 3停了一台机器,还有少量请求打到它上面,算法有问题吗?
参考回答

多半不是算法,是健康检查有间隔和失败阈值,比如 5s 探一次、连续 3 次失败才摘除,这十几秒内照样会分过去。发布时应该先主动摘流量再停服务。

追问 4网关后端失败就无限重试换节点,算故障转移吗?
参考回答

不算,这是在放大故障。重试要有上限和超时,只对幂等请求重试,否则一个后端慢了,重试流量能把整个集群拖垮。

追问 5入口已经有负载均衡器了,是不是就没有单点了?
参考回答

负载均衡器自己就是单点。要么主备加 VIP 漂移,要么前面再用 DNS 或云厂商的 SLB 做多实例。

# 1. 轮询(Round Robin)

30 秒速记

  • 轮询:维护一个游标,请求来了给游标指的那台,然后游标 +1,到底回到第一台
  • 均衡的是「请求次数」,不是 CPU、耗时这些真实负载
  • 适合机器配置差不多、请求耗时也差不多的场景
  • 机器性能不一样 → 弱机器先排队;请求有快有慢 → 慢请求扎堆的那台先扛不住
  • 轮询本身不知道节点死活,要配合健康检查把坏节点从列表里拿掉

轮询就是排队发号,A、B、C、A、B、C 这么轮着来。 实现最简单,一个游标取模就完事,它保证的是每台机器拿到的请求数差不多。问题是它只数次数,不管一个请求是 10ms 还是 10s,也不管这台机器是 16 核还是 4 核,所以只适合机器同配置、请求耗时接近的场景。

const nodes = ['A', 'B', 'C']; let i = 0
const pick = () => nodes[i++ % nodes.length]
console.log(Array.from({ length: 7 }, pick).join(' ')) // A B C A B C A
@前端进阶之旅: 代码已经复制到剪贴板

轮询算法把每个请求轮流发送到每个服务器上。

下图中,一共有 6 个客户端产生了 6 个请求,这 6 个请求按 (1, 2, 3, 4, 5, 6) 的顺序发送。(1, 3, 5) 的请求会被发送到服务器 1,(2, 4, 6) 的请求会被发送到服务器 2。


该算法比较适合每个服务器的性能差不多的场景,如果有性能存在差异的情况下,那么性能较差的服务器可能无法承担过大的负载(下图的 Server 2)。


原理拆解: 轮询调度器维护一个指向下一台服务器的游标。请求到达时选择游标对应的节点,再将游标移动到后继节点;到达列表末尾后回到第一台,因此其时间复杂度通常为 O(1)。只要节点列表不变,连续请求就会形成可预测的循环序列。它均衡的是调度次数,而不是每个请求消耗的 CPU、内存、网络带宽或处理时间。

最小验证: 假设节点列表为 [A, B, C],初始游标指向 A,七个请求的分配结果依次是 A、B、C、A、B、C、A,计数为 3:2:2;继续发送到第九个请求后,三台节点均得到三个请求。由此可见,短时间窗口内允许最多一次左右的数量差异,完整轮询周期内才会表现为请求数相等。

边界与反例: 若 A 每秒能处理 100 个请求,而 B 只能处理 20 个,二者仍各收一半请求,B 会更早出现排队和超时。即使机器性能相同,一个耗时 10 ms 的请求和一个耗时 10 s 的请求也被视为同一次分配,所以慢请求集中时仍会失衡。轮询本身也不能证明节点可用;节点退出后是否剔除、恢复后何时加入,取决于轮询之外的节点管理机制。

工程验证: 压测时应同时观察各节点请求计数、响应时间、错误率、队列长度和资源利用率。若请求计数接近但某节点的延迟、积压或利用率持续偏高,说明调度次数均匀而工作量并不均匀。还应验证节点列表变化时游标是否仍落在有效范围,并用多轮连续请求确认分配序列与配置中的节点顺序一致。

面试官追问

追问 1三台机器请求数 1:1:1,但有一台一直超时,能说跟调度无关吗?
参考回答

不能,轮询均衡的只是次数。那台可能配置低,或者正好分到了一批慢请求,得看各节点的延迟、队列和 CPU,光看请求数说明不了问题。

追问 2发了 7 个请求,分布是 3:2:2,轮询是不是坏了?
参考回答

没坏,A B C A B C A 正好是 3:2:2。一个完整周期没走完时差一个很正常,发到 9 个再看。

追问 3一台机器下线了,轮询还每隔几次打到它,问题出在哪?
参考回答

轮询算法不负责判断节点死活。要查健康检查有没有把它摘掉,以及节点列表变化后游标会不会落到失效的位置。

追问 4A 的性能是 B 的五倍,两台都要保留,还用普通轮询吗?
参考回答

不用,普通轮询会让 B 分到一半流量先被压垮。改加权轮询,按 5:1 配权重。

# 2. 加权轮询(Weighted Round Robbin)

30 秒速记

  • 加权轮询:给机器配权重,强的权重大,一个周期里被选中的次数和权重成正比
  • 权重 5:1 → 每 6 个请求 A 拿 5 个、B 拿 1 个
  • 简单实现是 AAAAAB 连着发;Nginx 用的是平滑加权轮询,B 会穿插在中间
  • 适合机器性能不同、请求成本差不多的场景
  • 权重是静态配置,机器降频、长任务扎堆时它不会自己调整

加权轮询是在轮询上加了权重,让配置高的机器多干活。 权重 5:1 就是每 6 个请求里 5 个给 A、1 个给 B。最笨的实现是连发 5 个给 A 再给 B,这样 A 会被瞬间集中打一波,所以 Nginx 用平滑加权轮询:每轮给每个节点的当前值加上自己的权重,选当前值最大的,然后把它减去总权重,结果比例不变但请求是穿插分布的。它的局限和普通轮询一样,只管请求数量,不感知实时负载。

const ns = [{ n: 'A', w: 5, cur: 0 }, { n: 'B', w: 1, cur: 0 }]
const total = 6, out = []
for (let i = 0; i < 6; i++) {
  ns.forEach(x => (x.cur += x.w))
  const best = ns.reduce((a, b) => (b.cur > a.cur ? b : a))
  best.cur -= total; out.push(best.n)
}
console.log(out.join('')) // AAABAA,B 被穿插在中间