🌐 06-分布式¶
核心概念¶
(a) 🗂️ 分布式八股主线:一致性是灵魂,消息与事务是骨架¶
分布式面试题有一条主线:先立 CAP 理论的大前提,再谈一致性模型(Raft / Paxos),然后是消息队列、分布式事务、限流熔断降级、分布式 ID / 锁、负载均衡与一致性哈希这些组件,最后落到系统设计题(秒杀 / 短链 / Feed 流)。图里每条线都能展开成一节精读。
(该图在 GitHub/VSCode + mermaid 插件中可渲染)
flowchart TB
Dist["🌐 分布式八股全景"]
Dist --> Cap["🎯 CAP 理论"]
Cap --> Cons["📐 一致性模型<br/>Raft / Paxos"]
Dist --> Mq["📨 消息队列<br/>不丢 / 不重 / 顺序"]
Dist --> Tx["📝 分布式事务<br/>2PC / TCC / Saga"]
Dist --> Guard["🛡️ 限流 / 熔断 / 降级"]
Dist --> Id["🔢 分布式 ID 与分布式锁"]
Dist --> Lb["⚖️ 负载均衡与一致性哈希"]
Dist --> Design["🏗️ 系统设计题<br/>秒杀 / 短链 / Feed 流"]
- 🎯 CAP 理论:C 一致性、A 可用性、P 分区容错性三选二——网络分区必然存在(P 必选),所以实际是在 CP 与 AP 之间做选择。要能论证「为什么只能三选二」,并给真实系统归类(ZooKeeper 偏 CP,Eureka 偏 AP)。
- 📐 一致性模型:从强一致到最终一致的全谱要能排出来。Raft 背三点:领导者选举、日志复制、安全性保证;Paxos vs Raft 的对比(Paxos 难懂难实现,Raft 把决策拆成子问题、更工程化)是必答题。
- 📨 消息队列:MQ 的三大作用(解耦、异步、削峰)与一个代价(系统变复杂)。保证不丢消息要三环节逐一击破(生产端确认、broker 持久化、消费端手动 ack);不重复消费靠幂等三招(唯一 ID、去重表、状态机);顺序消息要单分区 + 顺序消费。
- 📝 分布式事务:2PC(两阶段提交,强一致但协调者单点、参与者阻塞)、TCC(Try-Confirm-Cancel,业务补偿、无锁)、Saga / 本地消息表(最终一致、异步)。方案对比表要能背,并能说出什么场景选哪个。
- 🛡️ 限流 / 熔断 / 降级:限流四件套(固定窗口、滑动窗口、漏桶、令牌桶)要能手写;熔断是「服务出问题时快速失败」的保险丝,半开状态探测恢复;降级是「保核心功能、砍非核心」的预案。三者组合是保护系统的三板斧。
- 🔢 分布式 ID 与分布式锁:分布式 ID 方案对比(UUID / 数据库自增 / Redis INCR / 雪花算法),雪花算法的时间戳 + 机器号 + 序列号结构是必背;分布式锁 Redis 版(SETNX + Lua,带过期时间与唯一标识)要能手写,ZooKeeper 临时顺序节点版也要了解。
- ⚖️ 负载均衡与一致性哈希:负载均衡算法(轮询、加权轮询、随机、最少连接、一致性哈希)对比;一致性哈希把 key 映射到环上,节点增减只影响一小部分 key,虚拟节点解决数据倾斜——这段有可运行 Python 代码演示。
- 🏗️ 系统设计题:秒杀(削峰 + 预扣库存 + 异步下单)、短链(发号器 + 重定向 + 缓存)、Feed 流(推拉结合 + 缓存时间线)都有标准套路;答题用「四步框架」(明确需求 → 估算 → 架构图 → 关键细节),任何题都能套。
面试定位:CAP / 一致性 / 消息队列 / 分布式事务 / 限流熔断 是后端与算法岗的必考高频。本文件按"理论 → 中间件 → 实践方案"组织,每节含原理、对比表、可运行代码与面试追问。 标记:🔴 必背 / 🟡 掌握 / 🟢 了解。
§1 CAP 理论(🔴 必背)¶
💡 定义(小白版):CAP 是分布式系统的三条硬指标:C 一致性(所有节点同一时刻看到同一份数据)、A 可用性(每个请求都能拿到响应)、P 分区容错(网络断了也能继续工作)。网络一定会断(P 逃不掉),所以断网时只能在 C 和 A 里二选一。 🏷️ 类比:你和朋友各记一份聚餐账目。断网没法同步时——要么暂停记账先对账(选 C 一致性),要么各自先记、回头再对(选 A 可用性)。生活里多数场景选后者。
1.1 三个要素的定义¶
- C(Consistency 一致性):所有节点在同一时刻读到相同的数据(线性一致性:任何读都能返回最近一次写的值)。
- A(Availability 可用性):只要收到请求,每个请求都必须成功响应(不保证返回最新数据,但必须"活着能答")。
- P(Partition tolerance 分区容错):网络发生分区(节点间消息丢失/延迟)时,系统仍能继续运行。
⚠️ 精确表述:CAP 不是"三选二",而是"当发生网络分区时,只能从 C 和 A 中选一个"。没有分区时 C 和 A 可以同时满足(如单机数据库)。
1.2 为什么"只能三选二"(关键论证)¶
假设一个分布式系统有节点 N1、N2,客户端 C 先向 N1 写入了值 v1,随后发生网络分区(N1 与 N2 之间断开):
| 选择 | 行为 | 后果 |
|---|---|---|
| 选 CP | 分区期间 N2 拒绝读请求(返回错误) | 牺牲可用性,保证一致性 |
| 选 AP | 分区期间 N2 用旧数据应答(返回 v0) |
牺牲一致性,保证可用性 |
| 选 CA | 不可能:分区已经发生,想同时一致又可用无解 | — |
核心一句话:网络分区是必然会发生的现实(不是假设),所以在设计时只能二选一。
1.3 实际系统的 CP/AP 归类¶
| 系统 | 取舍 | 原因 | 典型场景 |
|---|---|---|---|
| ZooKeeper | CP | 选举/过半提交,leader 失联时集群不可写 | 分布式协调、元数据 |
| etcd | CP | Raft 实现强一致 | k8s 元数据 |
| Eureka | AP | 节点间互相注册,失效节点不摘除仍响应 | 服务发现(宁可错不可停) |
| Nacos | 默认 AP,可切 CP | 支持两种模型 | 服务发现/配置 |
| Redis Cluster | AP(主从同步异步) | 主挂了从可能丢数据 | 缓存(容忍少量丢失) |
| MySQL 主从 | 弱一致(最终一致) | binlog 异步复制 | 读写分离 |
1.4 面试追问¶
- 问:"为什么说 CAP 是伪命题?"
- 答:因为分区是现实,所以系统必须保证 P,实际是 CP vs AP 的选择题;且 CAP 只描述"分区发生那一瞬",恢复后 C 和 A 都会回来。
- 问:"你设计系统选 CP 还是 AP?"
- 答:看业务。钱、库存、订单选 CP(宁可拒服务不可错账);feed、点赞数、在线状态选 AP(可用性优先)。并补一句"加缓存/异步补偿可以兼顾"。
§2 一致性模型(🟡 掌握)¶
💡 定义(小白版):一致性模型 = 描述「数据被写后,多久、多大范围让所有副本看到新值」的规则:强一致(写完立刻全看到)、弱一致(不保证)、最终一致(过一会儿必然全看到)。 🏷️ 类比:强一致像广播——所有人都听到主播说完才算完;最终一致像发到工作群里——各人点开看的时间不同,但最终都会看到那条消息。
2.1 强弱一致全谱¶
| 模型 | 描述 | 实现 | 例子 |
|---|---|---|---|
| 强一致(线性一致性) | 读总能看到最近写 | Raft/Paxos 过半提交 | ZooKeeper、etcd |
| 顺序一致 | 所有进程看到相同操作顺序 | 全局序 | 单机内存模型 |
| 因果一致 | 有因果关系的操作有序,并发可乱 | 版本向量 | 聊天系统 |
| 最终一致 | 无新写后,经过一段时间各副本收敛 | 异步复制/冲突解决 | DNS、Git、社交 |
收敛时间(不一致窗口)取决于复制延迟:MySQL 主从几毫秒~秒级,CDN 秒级~分钟级。
2.2 Raft 核心思想(🔴 背 3 个点)¶
💡 定义(小白版):Raft 是一种共识算法:让多台机器对「同一份操作日志」达成一致,过半节点同意才生效;通过选主(Leader)、复制日志、心跳保活三步保证。 🏷️ 类比:班级投票选班长——过半同意才通过(多数派);选出的班长负责传达(Leader 统一日志),班长失联了全班重新选(重新选举)。
Raft 把共识拆成 3 个子问题,可读性远超 Paxos:
- Leader 选举(Election):节点有角色
Leader / Follower / Candidate。Follower 超时未收到心跳 → 自增 term 并投票;过半票当选。任期 term 单调递增,防止旧 Leader 分裂。 - 日志复制(Log replication):客户端请求只发给 Leader,Leader 追加到本地日志 → 广播给 Follower → 过半节点确认后提交(commit)并应用到状态机。
- 安全性(Safety):选举时只选"日志最新"的候选者(比较 lastLogIndex/lastLogTerm);已提交的日志不会被覆盖——保证已提交日志永不丢失。
2.3 Paxos vs Raft 对比¶
| 维度 | Paxos | Raft |
|---|---|---|
| 理解难度 | 高(多轮提案、多数派含义难懂) | 低(状态机式角色切换) |
| Leader | 无固定 Leader(Basic Paxos) | 有明确 Leader |
| 日志顺序 | 不保证连续 | 保证连续(日志空洞用 prevLogTerm 校验) |
| 实现 | 复杂、易出错 | 工业界事实标准(etcd/consul/tiKV) |
| 成员变更 | 难 | Joint Consensus 解决 |
2.4 面试追问¶
- 问:"Raft 如何保证不丢已提交日志?"
- 答:① 过半确认才提交;② 选举限制(候选者日志必须不比当前 Leader 旧);③ 新 Leader 通过 prevLogIndex/prevLogTerm 强制覆盖不一致日志,但只覆盖未提交的。
- 问:"最终一致怎么检测数据冲突?"
- 答:版本号/时间戳/向量时钟,冲突时按业务策略合并(last-write-wins、CRDT、人工仲裁)。
§3 消息队列(🔴 必背)¶
💡 定义(小白版):消息队列(MQ)= 生产者和消费者之间的一层「中转缓冲」:生产者把消息放进队列就返回,消费者按自己的节奏取出处理——双方解耦、速度差被抹平。 🏷️ 类比:食堂打饭窗口——厨师(生产者)做好菜放窗口就走,学生(消费者)排队自己取;窗口缓冲了「做菜快 vs 吃饭慢」的速度差,厨师不会被学生堵住。
3.1 三大作用与一个代价¶
| 作用 | 说明 | 示例 |
|---|---|---|
| 异步 | 主流程不等待耗时不重要的子任务 | 下单 → 发短信/邮件 |
| 削峰 | 请求先入队,下游按自身节奏消费 | 秒杀、双 11 流量洪峰 |
| 解耦 | 生产/消费方互不知晓,可独立扩缩容 | 订单服务 → 库存/积分/日志 |
代价:多一跳 → 延迟增加、消息可能丢/重复、需保证顺序时更复杂。能不用就不用,用了就要想清楚三件事。
3.2 如何保证不丢消息(三环节逐一击破)¶
| 环节 | 风险 | 对策 |
|---|---|---|
| 生产端 | 发送失败/发送成功但没落盘 | send() 同步确认(ack);失败重试 + 本地消息表兜底 |
| Broker 存储 | 机器宕机内存数据丢失 | 刷盘策略(Kafka acks=all + min.insync.replicas);副本机制(ISR) |
| 消费端 | 消费后未提交 offset 就 crash → 重复消费 | 先处理业务再提交 offset(at-least-once);幂等兜底 |
⚠️ Kafka 默认是 at-least-once(至少一次):不丢但可能重复 → 必须配合幂等消费。要 exactly-once 需事务 + 幂等 Producer(较复杂)。
3.3 如何保证不重复消费(幂等三招)¶
- 唯一键去重表:消费前 INSERT IGNORE 业务唯一键(订单号/流水号),插入失败说明已处理。
- 版本号/状态机:
UPDATE ... WHERE version = ?,影响行数为 0 表示已被处理。 - Redis SetNX:
SETNX biz:order:123 1,返回 0 表示已消费过。
3.4 如何保证顺序消息¶
- 单分区模型:同一业务 key 哈希到同一个分区,分区内天然有序(Kafka);消费时单线程。
- RocketMQ:
MessageQueueSelector按订单 ID 选队列,同一订单进同一队列。 - RabbitMQ:单队列 + 单消费者(牺牲并行度换顺序)。
3.5 主流 MQ 对比(🟡 掌握)¶
| 特性 | Kafka | RocketMQ | RabbitMQ | Pulsar |
|---|---|---|---|---|
| 模型 | Topic/Partition | Topic/Queue | Exchange/Queue | Topic/Subscription |
| 吞吐 | 极高(百万级/s) | 高(十万级) | 中(万级) | 极高 |
| 顺序 | 分区内有序 | 队列内有序 | 单队列有序 | 订阅内有序 |
| 延迟 | 毫秒级 | 毫秒级 | 微秒级 | 毫秒级 |
| 消费确认 | offset 手动/自动 | ack | ack | ack |
| 适用 | 日志、大数据、流处理 | 电商事务消息、顺序 | 轻量业务解耦 | 云原生多租户 |
3.6 面试追问¶
- 问:"Kafka 为什么快?"
- 答:顺序写磁盘(追加日志)+ 页缓存(读命中内存)+ 零拷贝(sendfile 直接把页缓存发到网卡)+ 批量压缩。
- 问:"消息积压了怎么办?"
- 答:先扩容消费者(超过分区数需加分区),紧急时可临时转储(写文件/Redis),再逐步消费;定位是消费慢还是生产快。
§4 分布式事务(🟡 掌握,方案对比必考)¶
💡 定义(小白版):分布式事务 = 跨多个数据库/服务的一组操作,要求「要么全部成功,要么全部回滚」,不能出现「A 库扣了钱、B 库没加钱」的中间状态。 🏷️ 类比:多人接力转账——每一棒都必须成功,任何一棒失败整条链路作废重来,绝不留下半截账。
4.1 2PC(两阶段提交)¶
💡 定义(小白版):2PC(两阶段提交)= 由一个协调者先问所有参与者「都能提交吗」(第一阶段 Prepare 投票),全部同意再下令「都提交」(第二阶段 Commit)。 🏷️ 类比:集体合影——摄影师(协调者)先喊「都准备好了吗?」(Prepare),全员举手后再喊「拍!」(Commit);有人没准备好就取消重来(Abort)。
流程: 1. Prepare(阶段一):协调者向所有参与者发 prepare,参与者执行事务但不提交,本地写 undo/redo 日志,返回"可提交/不可提交"。 2. Commit/Abort(阶段二):全部同意 → 广播 commit;任一反对/超时 → 广播 rollback。
三大问题: - 同步阻塞:Prepare 后参与者一直占资源等待协调者指令。 - 协调者单点:协调者宕机则全体卡死。 - 脑裂风险:阶段二协调者与部分参与者失联,网络恢复后状态不一致。
改进:3PC 引入超时与 preCommit 减少阻塞,但仍不是严格共识;业界多用 Paxos/Raft 替换协调者(如 MySQL Group Replication)。
4.2 TCC(Try-Confirm-Cancel)¶
| 阶段 | 动作 | 例子(扣款+减库存) |
|---|---|---|
| Try | 预留资源(不真正扣) | 冻结 100 元、锁定 1 件库存 |
| Confirm | 确认执行(Try 全部成功) | 真正扣款、真正减库存 |
| Cancel | 回滚(任一 Try 失败) | 解冻金额、释放库存 |
优点:业务可控、性能好(无长事务锁);缺点:侵入性强,每个业务要写 Try/Confirm/Cancel 三套逻辑;要保证 Confirm/Cancel 幂等。
4.3 Saga / 本地消息表(最终一致方案)¶
Saga:一个长事务拆成多个本地事务,每个都有正向操作 + 补偿操作;失败时逆序执行补偿。 - 编排式(Orchestration):中央 Saga 引擎调度。 - 协同式(Choreography):事件驱动链式触发。
本地消息表:业务表和消息表同一个本地事务写入;后台任务扫描消息表发 MQ,消费成功后删记录——生产端不丢消息的最简单可靠方案。
4.4 方案对比表(面试直接背)¶
| 方案 | 一致性 | 性能 | 业务侵入 | 适用 |
|---|---|---|---|---|
| 2PC | 强 | 低(长锁) | 低 | 单机强一致、短事务 |
| 3PC | 较强 | 中 | 低 | 减少阻塞的场景 |
| TCC | 强(业务保证) | 中 | 高(三套代码) | 资金类、必须实时确认 |
| Saga | 最终一致 | 高 | 中(补偿逻辑) | 长流程、允许短暂不一致 |
| 本地消息表 | 最终一致 | 高 | 中 | 与 MQ 配合的生产端可靠性 |
| MQ 事务消息 | 最终一致 | 高 | 低(半消息机制) | RocketMQ 场景 |
4.5 面试追问¶
- 问:"2PC 和 TCC 怎么选?"
- 答:业务链路短、要强一致、能接受锁 → 2PC;链路长、要性能、资源预留明确 → TCC;能接受最终一致 → Saga/本地消息表。
- 问:"TCC 的 Confirm 失败了怎么办?"
- 答:重试 Confirm(必须幂等);多次失败进人工/定时任务对账。
§5 限流、熔断、降级(🔴 必背概念 + 代码)¶
💡 定义(小白版):三件套是保护系统的三道闸门:限流 = 控制单位时间进来的请求量(超了就拒绝/排队);熔断 = 下游接口连续失败时主动「短路」,不再把请求发进去,让它喘口气恢复;降级 = 压力大时主动关掉非核心功能(如评论、推荐),保住核心交易。 🏷️ 类比:高速公路管控——限流 = 收费站限量放行;熔断 = 前方塌方直接封路(不派车过去送死);降级 = 关闭观景台出口,把道路资源全让给主路。
5.1 限流四件套¶
| 算法 | 原理 | 优点 | 缺点 | 适用 |
|---|---|---|---|---|
| 固定窗口 | 每秒计数,超限拒绝 | 简单 | 窗口边界突刺(前 999ms 无请求最后 1ms 1000 个) | 粗粒度 |
| 滑动窗口 | 窗口按时间滑,计数精确 | 平滑 | 比固定窗口多存一个窗口计数 | 较精确 |
| 漏桶(Leaky Bucket) | 请求入桶,恒定速率流出 | 输出绝对平滑 | 不能应对突发(有突发也匀速) | 平滑流出场景 |
| 令牌桶(Token Bucket) | 恒速放令牌,请求取令牌 | 允许突发(积攒令牌) | 实现略复杂 | 秒杀、网关(最常用) |
令牌桶 Python 实现(可运行):
import time
import threading
class TokenBucket:
def __init__(self, capacity, rate):
self.capacity = capacity # 桶容量(最大突发)
self.tokens = capacity # 当前令牌数
self.rate = rate # 每秒补充令牌数
self.lock = threading.Lock()
self.last = time.time()
def acquire(self, n=1):
with self.lock:
now = time.time()
self.tokens = min(self.capacity,
self.tokens + (now - self.last) * self.rate)
self.last = now
if self.tokens >= n:
self.tokens -= n
return True
return False
# 使用:QPS 上限 5,容量 3(允许突发 3 个)
bucket = TokenBucket(capacity=3, rate=5)
for _ in range(10):
print('放行' if bucket.acquire() else '拒绝')
time.sleep(0.1)
5.2 熔断(Circuit Breaker)¶
状态机(Hystrix 三态):
CLOSED(正常)--失败率超阈值(N)--> OPEN(熔断,直接快速失败)
OPEN --超时冷却--> HALF_OPEN(放少量探测请求)
HALF_OPEN --探测成功--> CLOSED
HALF_OPEN --探测失败--> OPEN
- 熔断的目的:下游已挂时快速失败,而不是让调用方继续堆积超时(防止雪崩)。
- 关键参数:失败率阈值(如 50%)、窗口大小、熔断持续时间、半开探测请求数。
5.3 降级(Fallback)¶
- 熔断 vs 降级区别:熔断是系统自我保护(下游故障触发);降级是主动预案(预期到高峰,主动关掉非核心功能)。
- 例子:大促时降级"猜你喜欢"推荐、降级日志采集;返回兜底数据或缓存旧值。
5.4 面试追问¶
- 问:"限流是加在网关还是应用?"
- 答:网关层做全局粗粒度限流(IP/用户维度)+ 应用层做业务细粒度限流(接口维度),两级配合。
- 问:"Sentinel 与 Hystrix 区别?"
- 答:Hystrix 基于线程池/信号量隔离,Sentinel 基于滑动窗口实时统计、支持热点限流与系统自适应,且不依赖线程池。
§6 分布式 ID 与分布式锁(🔴 必背)¶
💡 定义(小白版):分布式 ID = 在多台服务器环境下仍保证全局唯一的编号(雪花算法等生成);分布式锁 = 跨进程的互斥手段,保证同一时刻只有一个节点能执行临界区代码。 🏷️ 类比:分布式 ID = 全国统一身份证号(人人不同);分布式锁 = 公共洗手间挂「有人」牌——谁挂上谁用,用完摘牌,挂不上就等。
6.1 分布式 ID 方案对比¶
| 方案 | 特点 | 有序 | 缺点 |
|---|---|---|---|
| UUID | 本地生成、无中心 | 无序 | 32 位字符串、索引碎片化 |
| 数据库自增 | 简单 | 有序 | 单点、性能低 |
| 号段模式 | 一次取一段 | 有序 | 依赖 DB |
| 雪花算法 | 时间戳+机器+序列 | 趋势有序 | 依赖时钟(时钟回拨问题) |
| Redis INCR | 简单 | 有序 | 依赖 Redis、量大有瓶颈 |
雪花算法 64 位布局:
0 | 41bit 时间戳(ms) | 10bit 机器ID | 12bit 序列号
每秒可生成 2^12 = 4096 个/ms = 409.6 万个/秒;时钟回拨时暂停或拒绝生成。
6.2 Redis 分布式锁(SETNX + Lua,🔴 手写)¶
正确姿势(Redisson 风格):
-- 加锁:SET key value NX EX timeout(一条命令保证原子)
-- 释放:先比对 value(防误删别人的锁)再 DEL,Lua 保证原子
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end
要点清单:
1. 加锁:SET lock:key unique_id NX EX 30 —— NX 保证互斥、EX 防死锁、unique_id 防误删。
2. 释放:必须 Lua 比较唯一标识再删(否则可能删掉别的线程刚获取的锁)。
3. 续期:业务没跑完前用看门狗(WatchDog)每 10s 续期 30s;进程挂了自动过期。
4. Redlock 争议:在 5 个独立 Redis 上同时加锁,过半成功才算获锁——Martin Kleppmann 与作者争论过其是否真的安全(时钟跳跃/GC 停顿问题),一般业务用单节点 + 看门狗足够。
Python 可运行版:
import uuid
import time
import redis
r = redis.Redis(host='localhost', port=6379)
def acquire_lock(name, timeout=10, ttl=30):
token = uuid.uuid4().hex
ok = r.set(name, token, nx=True, ex=ttl)
if ok:
return token
return None
def release_lock(name, token):
# 用 Lua 保证"比对+删除"原子
lua = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"
return bool(r.eval(lua, 1, name, token))
6.3 ZooKeeper 分布式锁¶
- 创建临时顺序节点
/lock/lock_0001,取最小序号者获锁;序号不是最小的则 watch 前一个节点,前一个删除后重新竞争。 - 优点:临时节点 + 会话机制天然防死锁(客户端挂了节点自动删除);缺点:性能不如 Redis、依赖 ZK 可用性。
6.4 面试追问¶
- 问:"Redis 锁过期了但业务没执行完怎么办?"
- 答:看门狗续期 + 释放时校验 token;若还是过期了,用 Redisson 的锁续期 + 可重入,极端情况接受互斥窗口(或用 ZK 语义)。
- 问:"分布式锁和本地锁什么区别?"
- 答:本地锁只对本进程线程有效(如
threading.Lock);跨进程/跨机器必须用 Redis/ZK/DB 等外部协调器。
§7 负载均衡与一致性哈希(🟡 掌握 + 代码)¶
💡 定义(小白版):负载均衡 = 把大量请求按策略分给多台服务器,避免一台忙死、别的闲着;一致性哈希 = 一种分片策略:服务器增减时,只迁移 1/n 左右的数据,而不是全部重新分配。 🏷️ 类比:负载均衡 = 医院分诊台,把病人分到不同诊室(轮询/按空闲程度);一致性哈希 = 环形公交站,新开一站只影响它前后一小段乘客,其他人照常。
7.1 负载均衡算法对比¶
| 算法 | 原理 | 问题 |
|---|---|---|
| 轮询 RR | 依次分发 | 权重不敏感 |
| 加权轮询 | 按权重比例 | 热点可能偏移 |
| 最少连接 | 分给连接最少的 | 需实时统计 |
| 一致性哈希 | 哈希环 + 顺时针找节点 | 解决"节点增减只影响少量 key" |
7.2 一致性哈希原理与虚拟节点¶
💡 定义(小白版):一致性哈希把服务器和 key 都哈希到一个 0~2³²-1 的环上,key 顺时针遇到的第一个服务器就是归属;虚拟节点 = 每台物理服务器在环上放很多虚拟点,让负责区间更均匀。 🏷️ 类比:环形公交站——乘客按「顺时针第一个站」上车;新加一站只影响它附近一小段乘客。虚拟节点 = 每家公司多设几个分站点,避免一家独占黄金路段。
问题背景:普通 hash(key) % N 在节点数变化时,几乎所有 key 都要迁移 → 缓存雪崩。
一致性哈希: 1. 把节点 hash 到 0~2^32 圆环上; 2. key 也 hash,顺时针找第一个节点; 3. 节点增减时,只有环上相邻区间的 key 受影响(O(1/N) 比例迁移)。
虚拟节点解决"节点少导致数据倾斜":每个物理节点复制成 160 个虚拟节点均匀撒在环上。
7.3 Python 实现(可运行)¶
import hashlib
import bisect
class ConsistentHash:
def __init__(self, nodes, replicas=160):
self.replicas = replicas
self.ring = [] # (hash, node) 升序
self.node_map = {}
for node in nodes:
self._add_node(node)
def _hash(self, key):
return int(hashlib.md5(key.encode()).hexdigest(), 16) % (2 ** 32)
def _add_node(self, node):
for i in range(self.replicas):
h = self._hash(f"{node}#{i}")
self.ring.append((h, node))
self.ring.sort()
def get_node(self, key):
h = self._hash(key)
idx = bisect.bisect_left(self.ring, (h, '')) % len(self.ring)
return self.ring[idx][1]
# 验证:移除一个节点后大部分 key 仍落在原节点
nodes = ['A', 'B', 'C']
ch = ConsistentHash(nodes)
keys = [f'key-{i}' for i in range(1000)]
before = {k: ch.get_node(k) for k in keys}
ch2 = ConsistentHash(['A', 'B']) # 摘掉 C
moved = sum(1 for k in keys if ch2.get_node(k) != before[k])
print(f'移除节点后 key 迁移比例: {moved / len(keys):.1%}') # 远小于 1/3 而是接近 1/3 的环区间
7.4 面试追问¶
- 问:"一致性哈希在 Redis 集群里还用吗?"
- 答:Redis Cluster 用 CRC16 % 16384 slot 代替一致性哈希(16384 个槽位稳定、支持迁移),一致性哈希主要用于自研网关/缓存分片。
- 问:"虚拟节点太多会怎样?"
- 答:内存与排序开销增大;160 是工程上平衡点。
§8 高频追问速答(1 分钟版)¶
💡 用法(一句话):本节是「考前冲刺卡」——每问先自己默答 30 秒,再对照速答修正;答不出就翻回对应小节看定义。
| 问题 | 一句话答案 |
|---|---|
| 什么是幂等 | 同一操作执行多次结果一致(按唯一键去重/版本号) |
| 为什么 Kafka 快 | 顺序写盘 + 页缓存 + 零拷贝 + 批量 |
| 2PC 为什么慢 | Prepare 后长锁等待协调者 |
| 分布式锁怎么防误删 | 存唯一 token,删除前 Lua 比对 |
| 熔断和降级区别 | 熔断被动保护下游,降级主动牺牲非核心 |
| 最终一致怎么实现 | 异步复制/消息队列 + 幂等 + 对账 |
§9 经典系统设计题速答(高频追问)¶
💡 定义(小白版):系统设计题 = 面试中现场设计一个能扛高并发的系统(秒杀/短链/Feed 流等),考察容量估算(QPS、存储量)、架构选型(缓存/队列/分库分表)与取舍表达。 🏷️ 类比:城市规划——先算人口(QPS/存储),再定道路(架构骨架)、路口红绿灯(缓存/限流)、应急车道(降级/熔断),最后讲清「为什么这么修」。
9.1 设计一个秒杀系统(下单链路)¶
- 前端:按钮置灰 + 本地令牌(防重复点击)
- 接入层:网关令牌桶限流(按 IP/用户),CDN 承载静态页
- 削峰:MQ 削峰,异步下单(限"预扣库存"进入队列)
- Redis 预扣库存:
DECR stock原子扣减,<=0 直接返回"已抢光"(防超卖) - DB 落单:消费队列写订单 + 扣 DB 库存(带唯一订单号幂等)
- 兜底:超时未支付释放 Redis 库存;对账任务处理不一致
防超卖本质:把库存扣减收敛到一个原子操作(Redis DECR 或 DB UPDATE stock SET n=n-1 WHERE n>0)。
9.2 设计一个短链系统(tinyurl)¶
- 发号器:雪花算法/DB 自增拿全局唯一 id → base62 编码(62^7 ≈ 3.5 万亿)→ 短码
- 存储:MySQL(long_url 唯一索引查重)+ Redis 缓存
- 跳转:
GET /{code}→ 查缓存 → 查库 →302重定向 - 扩展:分库分表按短码哈希;布隆过滤器拦截不存在短码
9.3 设计一个朋友圈 Feed 流¶
- 推模式(写扩散):发帖时写入所有粉丝的 inbox(实时但写放大,适合小 V)
- 拉模式(读扩散):查看时合并关注列表的最新帖(读放大,适合大 V)
- 混合:大 V 拉模式、普通用户推模式(Twitter 的经典方案)
- 缓存:Redis 存 timeline list(每用户 zset 按时间戳),DB 是冷备
9.4 设计一个限流配置中心¶
- 配置存 Apollo/Nacos(支持热更新)
- 限流规则下发到网关本地缓存(每 N 秒拉取一次 + 长轮询推送)
- 指标采集(QPS/失败率)上报到监控 → 触发动态降级/扩容
9.5 面试答题框架(无论哪题都这样讲)¶
- 澄清需求:QPS 多少?数据量多大?一致性要求?可用性要求?
- 画架构:客户端 → LB → 网关(限流/鉴权)→ 服务(无状态)→ 缓存 → DB/MQ
- 逐层说细节:数据模型、缓存怎么用、队列解决什么问题、失败怎么兜底
- 说权衡:CAP 取向、选型理由、瓶颈在哪、怎么扩容
⚠️ 高频扣分点:只画图不讲"为什么";不提限流/缓存/异步;不说扩展性假设(单机 vs 万级 QPS 方案根本不同)。
验收:🔴 条目能 1 分钟盲讲;能手写令牌桶、Redis 分布式锁(Lua)、一致性哈希;能对比 2PC/TCC/Saga;拿到系统设计题能按"澄清→架构→细节→权衡"四步讲满 5 分钟。