跳转至

🌐 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:

  1. Leader 选举(Election):节点有角色 Leader / Follower / Candidate。Follower 超时未收到心跳 → 自增 term 并投票;过半票当选。任期 term 单调递增,防止旧 Leader 分裂。
  2. 日志复制(Log replication):客户端请求只发给 Leader,Leader 追加到本地日志 → 广播给 Follower → 过半节点确认后提交(commit)并应用到状态机。
  3. 安全性(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 如何保证不重复消费(幂等三招)

  1. 唯一键去重表:消费前 INSERT IGNORE 业务唯一键(订单号/流水号),插入失败说明已处理。
  2. 版本号/状态机:UPDATE ... WHERE version = ?,影响行数为 0 表示已被处理。
  3. 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 设计一个秒杀系统(下单链路)

  1. 前端:按钮置灰 + 本地令牌(防重复点击)
  2. 接入层:网关令牌桶限流(按 IP/用户),CDN 承载静态页
  3. 削峰:MQ 削峰,异步下单(限"预扣库存"进入队列)
  4. Redis 预扣库存:DECR stock 原子扣减,<=0 直接返回"已抢光"(防超卖)
  5. DB 落单:消费队列写订单 + 扣 DB 库存(带唯一订单号幂等)
  6. 兜底:超时未支付释放 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 面试答题框架(无论哪题都这样讲)

  1. 澄清需求:QPS 多少?数据量多大?一致性要求?可用性要求?
  2. 画架构:客户端 → LB → 网关(限流/鉴权)→ 服务(无状态)→ 缓存 → DB/MQ
  3. 逐层说细节:数据模型、缓存怎么用、队列解决什么问题、失败怎么兜底
  4. 说权衡:CAP 取向、选型理由、瓶颈在哪、怎么扩容

⚠️ 高频扣分点:只画图不讲"为什么";不提限流/缓存/异步;不说扩展性假设(单机 vs 万级 QPS 方案根本不同)。


验收:🔴 条目能 1 分钟盲讲;能手写令牌桶、Redis 分布式锁(Lua)、一致性哈希;能对比 2PC/TCC/Saga;拿到系统设计题能按"澄清→架构→细节→权衡"四步讲满 5 分钟。

教程来源:Akun-python/autumn-recruitment。 MIT 许可证全文。