面试题集锦:分布式系统问答大全

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
正文
Generated by kimi-k2.6 model
分布式系统核心面试指南
定位:Senior/Staff 级别分布式系统面试核心知识点,覆盖理论、一致性、锁、事务、协议、稳定性六大板块。 目标:不只是背诵 CAP,而是能在面试中深入讨论实现细节、权衡取舍和工程实践。
目录
1. 分布式理论基础
1.1 CAP 定理
TL;DR
分区容错性是分布式系统的"底线",实际设计是在 CP 和 AP 之间做权衡,没有完美的 CA 系统。
1. 场景与背景
设计分布式数据库、缓存、消息队列时,面试官必问 CAP。比如:
- "Redis Cluster 是 AP 还是 CP?"
- "ZooKeeper 是 CP 还是 AP?"
- "如果网络分区了,你的系统怎么保证可用性?"
2. 理论原理
CAP 不可能三角:一个分布式系统最多同时满足其中两项。
| 维度 | 含义 | 类比 |
|---|---|---|
| C (Consistency) | 所有节点在同一时刻看到的数据一致 | 银行转账后余额立即同步 |
| A (Availability) | 每个请求都能在有限时间内得到响应(不保证最新) | 12306 抢票时能查到票,可能已卖完 |
| P (Partition Tolerance) | 网络分区后系统仍能继续运行 | 两地机房断网后各自还能服务 |
核心洞察:
- P 必须被满足。单机系统可以不要 P,但分布式系统必须处理网络分区,否则不是分布式系统。
- 所以真正的选择是 CP vs AP。
CP 系统(放弃可用性,保证一致性):
- ZooKeeper、etcd、Consul、HBase、MongoDB(可配置)
- 网络分区时,拒绝写入或返回错误,保证数据不脏
AP 系统(放弃强一致,保证可用性):
- Cassandra、DynamoDB、Eureka、Redis Cluster
- 网络分区时继续服务,但可能读到旧数据,通过最终一致性修复
3. 图解
+------------------+
| Consistency |
| (一致性) |
+--------+---------+
|
+-------------+-------------+
| |
+---v---+ +-----v-----+
| CA | | CP |
|(单点) | | ZooKeeper |
|MySQL | | etcd |
+---+---+ +-----+-----+
| |
| +-----------+ |
+-----> Partition <---------+
| Tolerance |
+-----+-----+
|
+-----v-----+
| AP |
| Cassandra |
| DynamoDB |
+-----------+
4. 业界实践
阿里巴巴:
- 双十一交易核心链路采用 CP 设计(基于 XA/TCC 的分布式事务),确保库存扣减的强一致性。
- 商品详情、搜索推荐采用 AP 设计,允许秒级延迟,通过消息队列异步同步。
Shopify:
- 订单系统使用 CP(PostgreSQL + 分布式锁),商品目录使用 AP(Elasticsearch 异步索引)。
5. 方案对比
| 系统 | CAP 倾向 | 分区行为 | 适用场景 |
|---|---|---|---|
| ZooKeeper | CP | 分区时不可写 | 配置中心、leader 选举 |
| etcd | CP | 分区时不可写 | K8s 核心存储、服务发现 |
| Eureka | AP | 分区时保留旧注册表 | 微服务注册中心 |
| Cassandra | AP | 分区时继续读写 | 大数据写密集型场景 |
| MongoDB | 可配置 | 默认 CP,可配 AP | 文档存储 |
6. 常见误区
❌ 误区 1:"我们的系统实现了 CAP 三者兼顾。" ✅ 正解:CAP 定理证明了三者不可能同时满足,说"兼顾"等于没理解定理。
❌ 误区 2:"选择了 AP 就不要一致性了。" ✅ 正解:AP 放弃的是强一致性,通过最终一致性(Eventual Consistency)和向量时钟/版本号修复数据。
❌ 误区 3:"数据库主从复制是 CP。" ✅ 正解:MySQL 异步主从是 AP(可能读到旧数据),半同步复制才是 CP 倾向。
7. 延伸问题
- "如果必须保证一致性,怎么在 CP 系统中提升可用性?"(Hint: Quorum NWR 机制)
- "BASE 理论和 CAP 的关系是什么?"
- "你的业务场景中,哪些模块应该是 CP,哪些应该是 AP?"
1.2 BASE 理论
TL;DR
BASE 是对 CAP 中 AP 方案的延伸:基本可用 + 软状态 + 最终一致,是互联网高并发系统的核心设计哲学。
1. 场景与背景
CAP 告诉我们要做权衡,BASE 告诉我们怎么在 AP 场景下优雅地设计系统。
2. 理论原理
| 维度 | 含义 | 实践 |
|---|---|---|
| Basically Available | 基本可用 | 限流降级、熔断、牺牲非核心功能 |
| Soft State | 软状态 | 允许中间状态(数据不一致),如订单"支付中" |
| Eventually Consistent | 最终一致 | 通过异步机制(MQ、Binlog)修复不一致 |
与 ACID 的对比:
| 特性 | ACID | BASE |
|---|---|---|
| 一致性 | 强一致 | 最终一致 |
| 可用性 | 事务内不可用 | 始终基本可用 |
| 设计目标 | 金融级准确 | 互联网级扩展 |
| 代表系统 | Oracle、MySQL | Cassandra、DynamoDB |
3. 代码示例:软状态设计
// 订单状态机:软状态允许中间态
type OrderStatus int
const (
OrderStatusPending OrderStatus = iota // 待支付 —— 软状态
OrderStatusPaying // 支付中 —— 软状态
OrderStatusPaid // 已支付 —— 最终一致
OrderStatusShipped
)
// 支付回调处理:允许中间状态,异步对账修复
func (s *OrderService) HandlePaymentCallback(ctx context.Context, orderID string) error {
// 1. 更新为"支付中"(软状态)
if err := s.repo.UpdateStatus(ctx, orderID, OrderStatusPaying); err != nil {
return fmt.Errorf("update paying status: %w", err)
}
// 2. 异步对账(最终一致)
s.asyncQueue.Publish(&PaymentReconcileEvent{
OrderID: orderID,
TTL: 30 * time.Second,
})
return nil
}4. 延伸问题
- "BASE 的'基本可用'具体怎么实现?"
- "最终一致的时间窗口内,用户看到不一致数据怎么办?"
1.3 PACELC 定理
TL;DR
PACELC 是 CAP 的扩展:如果有分区(P),在 A 和 C 之间选择;否则(E,Else),在延迟(L)和一致性(C)之间选择。
理论原理
PACELC =
If there is a Partition (P),
choose Availability (A) or Consistency (C);
Else (E),
choose Latency (L) or Consistency (C).
为什么需要 PACELC?
- CAP 只讨论分区场景,但日常系统大部分时间没有分区。
- 没有分区时,仍然存在延迟 vs 一致性的权衡(如异步复制 vs 同步复制)。
系统分类:
| 系统 | 分区时 | 正常时 | 说明 |
|---|---|---|---|
| DynamoDB | A | L | 分区时可用,正常时低延迟 |
| MongoDB | C | C | 始终优先一致,延迟高 |
| Cassandra | A | L | 可配置,默认 AP |
| CockroachDB | C | C | NewSQL,始终 CP |
延伸问题
- "为什么 CockroachDB 选择 C/C 而不是 A/L?"
- "你的系统在没有分区时,是选择延迟还是一致性?"
2. 一致性模型与数据分片
2.1 一致性模型谱系
TL;DR
一致性不是"有或无",而是一个光谱:从强一致到最终一致,选择取决于业务对延迟和正确性的容忍度。
1. 场景与背景
- "Kafka 消费者组的一致性是什么级别?"
- "微信朋友圈的点赞是强一致还是最终一致?"
2. 理论原理
一致性强度光谱(从左到右,强度递减):
线性一致 (Linearizable) --> 顺序一致 --> 因果一致 --> 会话一致 --> 单调读 --> 最终一致
↓ ↓ ↓ ↓ ↓ ↓
etcd ZooKeeper Kafka Redis MySQL从库 Cassandra
(全局时钟) (客户端序) (分区序) (连接序) (读自己写) (异步修复)
| 一致性级别 | 定义 | 实现代价 | 适用场景 |
|---|---|---|---|
| 线性一致 | 所有操作如同在单一副本上原子执行 | 高(RTT × 多数派) | 分布式锁、配置中心 |
| 顺序一致 | 所有进程看到的操作顺序一致 | 中高 | ZooKeeper |
| 因果一致 | 有因果关系的操作顺序一致 | 中 | 社交点赞、评论 |
| 最终一致 | 不保证中间状态,最终达到一致 | 低 | 商品库存、搜索索引 |
3. 代码示例:因果一致性实现
// 向量时钟实现因果一致性
type VectorClock map[string]uint64
func (vc VectorClock) HappensBefore(other VectorClock) bool {
allLessOrEqual := true
atLeastOneLess := false
for node, ts := range vc {
if other[node] < ts {
allLessOrEqual = false
break
}
if other[node] > ts {
atLeastOneLess = true
}
}
return allLessOrEqual && atLeastOneLess
}
// 合并两个向量时钟(取最大值)
func (vc VectorClock) Merge(other VectorClock) VectorClock {
merged := make(VectorClock)
for k, v := range vc {
merged[k] = v
}
for k, v := range other {
if v > merged[k] {
merged[k] = v
}
}
return merged
}4. 常见误区
❌ 误区:"最终一致性就是半小时后才一致。" ✅ 正解:最终一致的"最终"通常是毫秒到秒级,取决于网络延迟和同步机制。
5. 延伸问题
- "微信朋友圈的点赞用的是什么一致性模型?"
- "为什么 Kafka 不保证全局顺序一致,只保证分区有序?"
2.2 一致性 Hash 与虚拟节点
TL;DR
一致性 Hash 将节点和数据映射到同一个环上,节点增减时只影响相邻数据,虚拟节点解决数据倾斜问题。
1. 场景与背景
缓存集群(Redis/Memcached)扩容缩容时,传统 Hash 会导致大量数据迁移。
2. 理论原理
传统 Hash 的问题:
server = hash(key) % N
// N 从 3 变 4 时,75% 的数据需要迁移
一致性 Hash 解法:
1. 将 0 ~ 2^32-1 映射成一个环
2. 节点 hash(ip) 映射到环上
3. 数据顺时针找到第一个节点
4. 增加/删除节点只影响相邻区间
虚拟节点:
- 问题:物理节点少时数据倾斜严重。
- 解法:每个物理节点创建 100~200 个虚拟节点,均匀分布在环上。
3. 代码示例
package consistenthash
import (
"hash/crc32"
"sort"
"strconv"
)
type Hash func(data []byte) uint32
type Map struct {
hash Hash
replicas int // 虚拟节点倍数
keys []int // 排序后的虚拟节点 hash
hashMap map[int]string // 虚拟节点 -> 物理节点
}
func New(replicas int, fn Hash) *Map {
m := &Map{
replicas: replicas,
hash: fn,
hashMap: make(map[int]string),
}
if m.hash == nil {
m.hash = crc32.ChecksumIEEE
}
return m
}
func (m *Map) Add(keys ...string) {
for _, key := range keys {
for i := 0; i < m.replicas; i++ {
hash := int(m.hash([]byte(strconv.Itoa(i) + key)))
m.keys = append(m.keys, hash)
m.hashMap[hash] = key
}
}
sort.Ints(m.keys)
}
func (m *Map) Get(key string) string {
if len(m.keys) == 0 {
return ""
}
hash := int(m.hash([]byte(key)))
// 二分查找第一个 >= hash 的节点
idx := sort.Search(len(m.keys), func(i int) bool {
return m.keys[i] >= hash
})
if idx == len(m.keys) {
idx = 0
}
return m.hashMap[m.keys[idx]]
}4. 业界案例
美团:
- 缓存中间件 Squirrel(基于 Redis Cluster)使用一致性 Hash + 虚拟节点,支持平滑扩容。
- 扩容时数据迁移量从传统 Hash 的 75% 降到约 1/N。
LinkedIn:
- Voldemort 分布式 KV 存储使用一致性 Hash,虚拟节点数默认 150。
5. 常见误区
❌ 误区:"一致性 Hash 能保证负载均衡。" ✅ 正解:没有虚拟节点时一致性 Hash 负载很不均衡,必须配合虚拟节点使用。
6. 延伸问题
- "一致性 Hash 和数据分片(Sharding)的区别是什么?"
- "如果节点宕机后恢复,数据怎么同步?"
3. 分布式锁
3.1 分布式锁核心要求
TL;DR
一个好的分布式锁必须同时满足:互斥性、防死锁、可重入、容错性,生产环境推荐使用 Redis Redisson 或 etcd。
1. 场景与背景
- "如何实现一个分布式锁?"
- "Redis 分布式锁和 ZooKeeper 分布式锁有什么区别?"
- "如果 Redis 锁的节点挂了怎么办?"
2. 理论原理
分布式锁的四个核心属性:
| 属性 | 说明 | 常见实现 |
|---|---|---|
| 互斥性 | 同一时间只有一个客户端持有锁 | SET NX EX |
| 防死锁 | 客户端崩溃后锁自动释放 | 设置 TTL |
| 可重入 | 同一线程可多次获取锁 | ThreadLocal + 计数器 |
| 容错性 | 部分节点故障锁仍然有效 | RedLock / etcd Lease |
3. 方案对比
| 方案 | 实现 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| Redis (单节点) | SET key value NX EX | 性能极高 (~10w QPS) | 单点故障、主从延迟 | 非关键业务 |
| RedLock | 向 N 个独立 Redis 节点加锁 | 容忍部分节点故障 | 时钟漂移问题 | 高可用场景 |
| ZooKeeper | 创建临时顺序节点 | 天然高可用、可重入 | 性能较低 (~1w QPS) | 强一致场景 |
| etcd | 基于 Lease TTL + 前缀 | 高可用、支持 Watch | 性能中等 | K8s 生态 |
3.2 Redis 分布式锁实现
代码示例:基础版
package redislock
import (
"context"
"fmt"
"time"
"github.com/google/uuid"
"github.com/redis/go-redis/v9"
)
type Lock struct {
client *redis.Client
key string
token string
ttl time.Duration
}
// Lock 获取锁(非阻塞)
func (r *RedisLock) Lock(ctx context.Context, key string, ttl time.Duration) (*Lock, error) {
token := uuid.New().String()
ok, err := r.client.SetNX(ctx, key, token, ttl).Result()
if err != nil {
return nil, fmt.Errorf("redis setnx: %w", err)
}
if !ok {
return nil, fmt.Errorf("lock already held")
}
return &Lock{client: r.client, key: key, token: token, ttl: ttl}, nil
}
// Unlock 释放锁(Lua 保证原子性)
var unlockScript = redis.NewScript(`
if redis.call("get", KEYS[1]) == ARGV[1] then
return redis.call("del", KEYS[1])
else
return 0
end
`)
func (l *Lock) Unlock(ctx context.Context) error {
res, err := unlockScript.Run(ctx, l.client, []string{l.key}, l.token).Result()
if err != nil {
return fmt.Errorf("unlock script: %w", err)
}
if res.(int64) == 0 {
return fmt.Errorf("lock not held or expired")
}
return nil
}代码示例:看门狗自动续期(Redisson 原理)
package redislock
import (
"context"
"sync"
"time"
)
// Watchdog 自动续期
type Watchdog struct {
client *redis.Client
key string
token string
ttl time.Duration
interval time.Duration
cancel context.CancelFunc
wg sync.WaitGroup
}
func (w *Watchdog) Start() {
ctx, cancel := context.WithCancel(context.Background())
w.cancel = cancel
w.wg.Add(1)
go func() {
defer w.wg.Done()
ticker := time.NewTicker(w.interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
// 续期:TTL 的 1/3 时间检查一次
w.client.Expire(ctx, w.key, w.ttl)
case <-ctx.Done():
return
}
}
}()
}
func (w *Watchdog) Stop() {
if w.cancel != nil {
w.cancel()
w.wg.Wait()
}
}3.3 RedLock 算法
TL;DR
向 N 个独立的 Redis 主节点申请锁,获取多数派(N/2+1)才算成功,释放时向所有节点发送释放命令。
原理
1. 获取当前时间戳 T1
2. 依次向 N 个 Redis 节点发送 SET key value NX PX ttl
3. 计算总耗时 = 当前时间 - T1
4. 如果成功获取 >= N/2+1 个节点,且总耗时 < ttl,则加锁成功
5. 释放锁时向所有节点发送 DEL(不管是否成功获取)
争议:RedLock 真的安全吗?
Martin Kleppmann 的批评(《How to do distributed locking》):
- 时钟漂移:如果节点时钟跳跃,锁可能提前过期。
- fencing token:RedLock 无法提供单调递增的 fencing token 防止延迟进程误删锁。
改进方案:
- 使用 fencing token(ZooKeeper 的 zxid 或 etcd 的 revision)。
- 或改用 etcd(基于 Raft,天然线性一致)。
3.4 ZooKeeper / etcd 分布式锁
ZooKeeper 实现原理
1. 客户端在 /locks 下创建临时顺序节点 /locks/lock_00000001
2. 检查自己是不是序号最小的节点
- 是:获取锁成功
- 否:Watch 前一个节点,等待删除事件
3. 持有锁期间保持会话心跳
4. 会话断开 → 临时节点自动删除 → 锁释放
优势:
- 临时节点会话断开自动删除,天然防死锁。
- 顺序节点天然支持公平锁(FIFO)。
etcd 实现原理
// etcd 分布式锁(基于 Lease + Transaction)
func (e *EtcdLock) Lock(ctx context.Context, key string, ttl int64) error {
// 1. 创建 Lease
lease, err := e.client.Grant(ctx, ttl)
if err != nil {
return err
}
// 2. 尝试写入(如果不存在)
txn := e.client.Txn(ctx).
If(clientv3.Compare(clientv3.CreateRevision(key), "=", 0)).
Then(clientv3.OpPut(key, e.value, clientv3.WithLease(lease.ID))).
Else(clientv3.OpGet(key))
resp, err := txn.Commit()
if err != nil {
return err
}
if !resp.Succeeded {
return fmt.Errorf("lock already held by %s", resp.Responses[0].GetResponseRange().Kvs[0].Value)
}
// 3. 自动续约
e.keepAlive(ctx, lease)
return nil
}4. 常见误区
❌ 误区:"Redis SET NX EX 就是完美的分布式锁。" ✅ 正解:单节点 Redis 存在主从延迟问题(主节点挂了,锁还没同步到从节点),关键业务用 RedLock 或 etcd。
❌ 误区:"RedLock 是绝对安全的。" ✅ 正解:RedLock 依赖时钟同步,存在时钟漂移风险。真正的安全需要 fencing token + 存储系统支持线性一致。
5. 延伸问题
- "如果锁过期了,业务还没执行完怎么办?"
- "RedLock 的时钟漂移问题怎么解决?"
- "ZooKeeper 和 etcd 做分布式锁,选哪个?"
4. 分布式事务
4.1 分布式事务理论模型
TL;DR
分布式事务没有银弹:2PC 强一致但阻塞,TCC/Saga 最终一致但业务侵入大,选型取决于一致性强弱和性能要求。
1. 场景与背景
- "下单扣库存减余额,如何保证一致性?"
- "TCC 和 Saga 有什么区别?"
- "Seata AT 模式原理是什么?"
2. 方案全景图
分布式事务方案谱系:
强一致 ──────────────────────────────────────> 最终一致
│ │
├── 2PC(两阶段提交) ├── 本地消息表
├── 3PC(三阶段提交) ├── Saga(编排式/协同式)
├── XA 规范 ├── TCC(Try-Confirm-Cancel)
└── Seata AT 模式(增强型 2PC) └── 最大努力通知
4.2 2PC / 3PC
2PC 原理
阶段一(投票):
Coordinator -> 询问所有 Participant 是否可以提交
Participant -> 执行本地事务,锁定资源,返回 Yes/No
阶段二(提交/回滚):
如果所有 Participant 返回 Yes:
Coordinator -> 发送 Commit 指令
Participant -> 提交本地事务,释放锁
如果有 Participant 返回 No:
Coordinator -> 发送 Rollback 指令
Participant -> 回滚本地事务,释放锁
2PC 的问题:
- 同步阻塞:Participant 锁定资源期间,其他请求必须等待。
- 单点故障:Coordinator 挂了,Participant 一直持有锁。
- 数据不一致:Coordinator 发送 Commit 后宕机,部分 Participant 没收到。
3PC 改进
阶段一(CanCommit):Coordinator 询问 Participant 是否"可以执行"(不锁定)
阶段二(PreCommit):Participant 预执行(锁定资源)
阶段三(DoCommit):真正提交或回滚
改进点:引入超时机制,减少阻塞时间。但实现复杂,网络分区时仍可能不一致。
4.3 TCC(Try-Confirm-Cancel)
TL;DR
TCC 将事务拆成预留(Try)、确认(Confirm)、撤销(Cancel)三个阶段,业务侵入大但性能高。
1. 原理
| 阶段 | 操作 | 示例(扣库存) |
|---|---|---|
| Try | 预留资源,执行业务检查 | 检查库存,冻结待扣减的库存 |
| Confirm | 真正执行业务 | 将冻结库存转为实际扣减 |
| Cancel | 释放预留资源 | 解冻库存 |
2. 代码示例
package tcc
import (
"context"
"fmt"
)
// InventoryTCCService 库存 TCC 接口
type InventoryTCCService interface {
Try(ctx context.Context, productID string, qty int) error
Confirm(ctx context.Context, productID string, qty int) error
Cancel(ctx context.Context, productID string, qty int) error
}
// 实现
type inventoryTCC struct {
repo InventoryRepository
}
func (s *inventoryTCC) Try(ctx context.Context, productID string, qty int) error {
// 1. 检查库存
inv, err := s.repo.Get(ctx, productID)
if err != nil {
return fmt.Errorf("get inventory: %w", err)
}
if inv.Available < qty {
return fmt.Errorf("insufficient inventory")
}
// 2. 冻结库存(幂等:检查是否已有冻结记录)
if err := s.repo.Freeze(ctx, productID, qty); err != nil {
return fmt.Errorf("freeze inventory: %w", err)
}
return nil
}
func (s *inventoryTCC) Confirm(ctx context.Context, productID string, qty int) error {
// 将冻结库存转为实际扣减(幂等操作)
return s.repo.DeductFrozen(ctx, productID, qty)
}
func (s *inventoryTCC) Cancel(ctx context.Context, productID string, qty int) error {
// 解冻库存(幂等操作)
return s.repo.Unfreeze(ctx, productID, qty)
}
// TCC Coordinator(简化版)
type TCCTransaction struct {
participants []TCCParticipant
}
func (t *TCCTransaction) Execute(ctx context.Context) error {
// Phase 1: Try all
for _, p := range t.participants {
if err := p.Try(ctx); err != nil {
// Try 失败,Cancel 所有已 Try 成功的
for _, done := range t.participants[:index] {
done.Cancel(ctx)
}
return err
}
}
// Phase 2: Confirm all(异步执行,失败重试)
for _, p := range t.participants {
go func(part TCCParticipant) {
for i := 0; i < 3; i++ {
if err := part.Confirm(ctx); err == nil {
return
}
time.Sleep(time.Second * time.Duration(i+1))
}
// 告警:人工介入
}(p)
}
return nil
}3. TCC 的难点
| 难点 | 解法 |
|---|---|
| 幂等性 | Confirm/Cancel 必须幂等(数据库唯一索引/状态机) |
| 悬挂 | Try 超时但后续到达,需检查事务状态 |
| 空回滚 | Try 未执行就 Cancel,需记录 Try 是否执行 |
| 幂等 + 防悬挂 + 空回滚 | 事务状态机:INIT → TRYING → CONFIRMING → CONFIRMED / CANCELLING → CANCELLED |
4.4 Saga 模式
TL;DR
Saga 将长事务拆分为多个本地事务,每个本地事务提交后立即释放资源,通过补偿事务回滚。
1. 两种实现方式
编排式 Saga(Choreography):
- 每个服务完成本地事务后,发送事件通知下一个服务。
- 优点:松耦合。
- 缺点:流程散落到各个服务,难以追踪。
协同式 Saga(Orchestration):
- 中央协调器(Saga Orchestrator)统一调度各个服务。
- 优点:流程集中,易于监控。
- 缺点:协调器是单点。
2. 代码示例:协同式 Saga
// Saga Orchestrator 定义订单创建流程
type OrderSaga struct {
orderSvc OrderService
inventorySvc InventoryService
paymentSvc PaymentService
}
func (s *OrderSaga) CreateOrder(ctx context.Context, req CreateOrderRequest) error {
saga := NewOrchestrator()
// Step 1: 创建订单(初始状态)
saga.AddStep(&Step{
Action: func() error {
return s.orderSvc.Create(ctx, req)
},
Compensate: func() error {
return s.orderSvc.Cancel(ctx, req.OrderID)
},
})
// Step 2: 扣库存
saga.AddStep(&Step{
Action: func() error {
return s.inventorySvc.Deduct(ctx, req.ProductID, req.Qty)
},
Compensate: func() error {
return s.inventorySvc.Restore(ctx, req.ProductID, req.Qty)
},
})
// Step 3: 扣款
saga.AddStep(&Step{
Action: func() error {
return s.paymentSvc.Charge(ctx, req.UserID, req.Amount)
},
Compensate: func() error {
return s.paymentSvc.Refund(ctx, req.UserID, req.Amount)
},
})
return saga.Execute(ctx)
}3. Saga vs TCC 对比
| 维度 | Saga | TCC |
|---|---|---|
| 资源锁定 | 不锁定,本地事务立即提交 | Try 阶段锁定 |
| 一致性 | 最终一致 | 最终一致 |
| 业务侵入 | 低(只需补偿逻辑) | 高(需拆成三段) |
| 性能 | 高 | 高 |
| 适用场景 | 长事务、跨多个服务 | 短事务、资源可预留 |
4.5 Seata AT 模式
TL;DR
Seata AT 是增强版 2PC:业务无侵入,通过代理数据源解析 SQL 生成前后镜像,利用全局锁保证写隔离。
1. 原理
1. 一阶段:
- 业务 SQL 正常执行
- Seata 代理数据源解析 SQL,生成 UNDO_LOG(前镜像 + 后镜像)
- 提交本地事务
2. 二阶段(成功):
- 异步删除 UNDO_LOG
3. 二阶段(失败):
- 根据 UNDO_LOG 的前镜像生成回滚 SQL
- 执行回滚
全局锁机制:
- Seata Server 维护全局锁表,防止脏写。
- 一阶段提交前,先获取全局锁;回滚时也要检查全局锁。
2. 代码示例(业务无侵入)
// 业务代码完全无感知
@GlobalTransactional
public void purchase(String userId, String productId, int qty) {
// 1. 扣库存(本地事务,自动生成 UNDO_LOG)
inventoryMapper.deduct(productId, qty);
// 2. 扣款(本地事务,自动生成 UNDO_LOG)
accountMapper.debit(userId, amount);
// 3. 创建订单
orderMapper.create(order);
// 如果这里抛异常,Seata 自动根据 UNDO_LOG 回滚库存和余额
}3. AT 模式的限制
- 隔离级别:默认读未提交,需全局锁才能实现读已提交。
- SQL 支持:复杂 SQL(如 JOIN、嵌套查询)可能无法解析。
- 性能损耗:代理数据源、全局锁竞争带来 10%~30% 性能损耗。
4.6 本地消息表
TL;DR
本地消息表是最终一致的经典方案:业务操作和消息记录在同一个本地事务中,后台轮询发送消息。
代码示例
// 下单时同时写入订单表和消息表(同一个事务)
func (s *OrderService) CreateOrder(ctx context.Context, req CreateOrderRequest) error {
return s.db.Transaction(func(tx *gorm.DB) error {
// 1. 创建订单
if err := tx.Create(&Order{...}).Error; err != nil {
return err
}
// 2. 写入消息表(保证和订单同事务)
msg := &MessageOutbox{
Topic: "order_created",
Payload: mustMarshal(req),
Status: MessageStatusPending,
CreatedAt: time.Now(),
}
if err := tx.Create(msg).Error; err != nil {
return err
}
return nil
})
}
// 后台轮询发送消息
func (r *MessageRelay) Start(ctx context.Context) {
ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
r.processPendingMessages(ctx)
case <-ctx.Done():
return
}
}
}
func (r *MessageRelay) processPendingMessages(ctx context.Context) {
var msgs []MessageOutbox
r.db.Where("status = ?", MessageStatusPending).
Limit(100).Find(&msgs)
for _, msg := range msgs {
if err := r.kafkaProducer.Send(msg.Topic, msg.Payload); err != nil {
continue // 下次重试
}
// 标记已发送
r.db.Model(&msg).Update("status", MessageStatusSent)
}
}4. 常见误区
❌ 误区:"分布式事务 = 2PC,2PC 性能差所以不用分布式事务。" ✅ 正解:现代系统普遍采用最终一致方案(TCC/Saga/本地消息表),只在关键链路(如金融转账)使用强一致。
❌ 误区:"Seata AT 模式完全无侵入。" ✅ 正解:AT 模式对业务代码无侵入,但需要引入 Seata 代理数据源、注册中心、全局锁表等基础设施。
5. 延伸问题
- "TCC 的悬挂、空回滚、幂等问题怎么解决?"
- "Saga 模式如果补偿也失败了怎么办?"
- "Seata AT 和 XA 的区别是什么?"
5. 一致性协议
5.1 Raft 协议
TL;DR
Raft 通过"强领导"模型简化共识:Leader 负责写入,Follower 被动复制,选举和安全性约束保证一致性。
1. 场景与背景
- "etcd 为什么用 Raft 不用 Paxos?"
- "Raft 选举过程详细说一下?"
- "脑裂(Split Brain)怎么解决?"
2. 核心机制
三个子问题:
- Leader 选举:超时触发选举,获得多数派投票者成为 Leader。
- 日志复制:Leader 将日志条目发送给 Follower,多数派确认后提交。
- 安全性:只有包含最新日志的节点才能成为 Leader,保证不丢失已提交日志。
节点状态:
Follower ----(超时未收到心跳)----> Candidate ----(获得多数票)----> Leader
^ |
+------------------(发现更高任期 Leader)------------------------------+
3. 选举流程详解
1. Follower 在 election timeout(150~300ms 随机)内未收到 Leader 心跳
2. 自增 currentTerm,转为 Candidate,给自己投票
3. 向所有节点发送 RequestVote RPC
4. 收到多数派(N/2+1)投票 → 成为 Leader
5. 成为 Leader 后立即发送空 AppendEntries(心跳),重置 Follower 超时
防止选举风暴:
- 随机化 election timeout(150~300ms)。
- 每个节点超时时间不同,降低同时触发选举的概率。
4. 日志复制
1. 客户端发送写请求到 Leader
2. Leader 将日志追加到本地 log[],标记为 uncommitted
3. Leader 发送 AppendEntries RPC 给所有 Follower
4. Follower 校验日志连续性(prevLogIndex/prevLogTerm 匹配)
5. 多数派 Follower 确认后,Leader 标记日志为 committed
6. Leader 应用日志到状态机,返回客户端成功
7. 后续心跳中携带 commitIndex,Follower 异步应用
5. 安全性约束
Election Restriction:
- Candidate 的日志必须至少和投票者一样新(lastLogTerm/lastLogIndex 比较)。
- 保证新 Leader 一定包含所有已提交日志。
Commit Restriction:
- Leader 只能提交当前任期的日志条目。
- 旧任期的日志不能通过计算副本数来提交,只能通过提交新任期日志间接提交。
6. 代码示例:简化版 Raft 投票逻辑
package raft
// RequestVote RPC handler
func (rf *Raft) RequestVote(args *RequestVoteArgs, reply *RequestVoteReply) {
rf.mu.Lock()
defer rf.mu.Unlock()
// 1. 任期检查
if args.Term < rf.currentTerm {
reply.Term = rf.currentTerm
reply.VoteGranted = false
return
}
// 2. 如果任期更大,转为 Follower
if args.Term > rf.currentTerm {
rf.currentTerm = args.Term
rf.state = Follower
rf.votedFor = -1
}
// 3. 检查是否已经投票给别人
if rf.votedFor != -1 && rf.votedFor != args.CandidateId {
reply.VoteGranted = false
return
}
// 4. Election Restriction:Candidate 日志至少和我一样新
lastLogIndex := len(rf.log) - 1
lastLogTerm := rf.log[lastLogIndex].Term
if args.LastLogTerm < lastLogTerm ||
(args.LastLogTerm == lastLogTerm && args.LastLogIndex < lastLogIndex) {
reply.VoteGranted = false
return
}
// 5. 投票
rf.votedFor = args.CandidateId
reply.VoteGranted = true
rf.electionTimer.Reset(randomTimeout()) // 重置选举超时
}7. 业界案例
etcd:
- 使用 Raft 实现高可用 KV 存储。
- 默认 5 节点集群,可容忍 2 节点故障。
- K8s 的所有配置数据存储在 etcd 中。
TiKV:
- PingCAP 的分布式 KV 层,使用 Multi-Raft(数据分片后每片一个 Raft Group)。
- 单集群支持 100+ TB 数据。
8. 常见误区
❌ 误区:"Raft 选举时,Candidate 一定能成为 Leader。" ✅ 正解:可能因网络分区导致无法获得多数派,或多个 Candidate 同时触发选举(平票),需要等待超时后重试。
❌ 误区:"Raft 提交日志后数据就一定不会丢。" ✅ 正解:Raft 保证的是已提交日志不丢,但提交前如果 Leader 挂了,客户端可能收到不确定结果(需业务幂等)。
9. 延伸问题
- "Raft 和 Paxos 的区别是什么?"
- "Raft 日志压缩(Snapshot)怎么实现?"
- "Multi-Raft 是什么?解决了什么问题?"
- "Raft 的读性能怎么优化?(ReadIndex / Lease Read)"
5.2 Paxos 协议
TL;DR
Paxos 是共识算法的鼻祖:两阶段(Prepare/Promise + Accept/Accepted)保证提案值的唯一性,但工程实现复杂。
1. 核心角色
| 角色 | 职责 |
|---|---|
| Proposer | 提出提案 (value) |
| Acceptor | 投票决定是否接受提案 |
| Learner | 学习已被选定的提案值 |
2. Basic Paxos 两阶段
Phase 1 (Prepare):
Proposer -> 发送 Prepare(n) 给多数派 Acceptor
Acceptor -> 如果 n > 已承诺的最大编号,则承诺不再接受更小编号,返回已接受的提案
Phase 2 (Accept):
Proposer -> 如果收到多数派回复,选择最大编号的 value(或自己的 value),发送 Accept(n, value)
Acceptor -> 如果 n >= 已承诺的最大编号,则接受该提案
3. Paxos vs Raft 对比
| 维度 | Paxos | Raft |
|---|---|---|
| 理解难度 | 高(数学证明) | 低(工程导向) |
| 领导模型 | 多 Proposer 竞争 | 强 Leader |
| 工程实现 | 复杂(Multi-Paxos 有多种实现) | 标准清晰 |
| 日志连续性 | 不保证(可能出现空洞) | 保证连续 |
| 代表系统 | Chubby、ZooKeeper(ZAB) | etcd、TiKV、Consul |
4. 延伸问题
- "为什么 ZooKeeper 用 ZAB 而不是原生 Paxos?"
- "Multi-Paxos 的 Leader 选举怎么实现?"
5.3 ZAB 协议(ZooKeeper Atomic Broadcast)
TL;DR
ZAB 是 Paxos 的变种,专为 ZooKeeper 设计:崩溃恢复 + 消息广播,保证全局有序和主从一致性。
1. 核心特点
- 主从架构:只有一个 Leader 处理写请求。
- 全局有序:所有更新按 zxid(64 位高 32 位 epoch + 低 32 位计数器)排序。
- 两阶段:崩溃恢复(选主+数据同步)+ 消息广播。
2. 崩溃恢复流程
1. 选举 Leader:选择 zxid 最大的节点
2. 数据同步:
- Leader 有而 Follower 没有:Leader 发送差异数据
- Follower 有而 Leader 没有(旧 Leader 的未提交日志):Follower 删除
3. 同步完成后进入消息广播模式
3. 消息广播
1. Leader 接收写请求,生成 zxid
2. 发送 Proposal 给所有 Follower
3. Follower 写入本地日志,发送 ACK
4. Leader 收到多数派 ACK,发送 Commit
5. Follower 应用日志到内存数据库
6. 系统稳定性
6.1 限流算法
TL;DR
限流是保护系统的第一道防线:令牌桶允许突发,漏桶平滑流量,滑动窗口精准统计,生产环境常组合使用。
1. 场景与背景
- "你的系统怎么防止被突发流量打垮?"
- "令牌桶和漏桶的区别是什么?"
- "滑动窗口限流怎么实现?"
2. 三种核心算法
令牌桶(Token Bucket):
- 桶以固定速率产生令牌
- 请求来时取令牌,有则处理,无则拒绝/等待
- 允许突发流量(桶满时瞬间消耗累积令牌)
类比:景区售票处,每小时放 1000 张票,可累积,游客来就拿票
漏桶(Leaky Bucket):
- 请求进入队列(桶),以固定速率处理
- 桶满则拒绝新请求
- 流量被平滑,不允许突发
类比:医院排队叫号,每小时看 50 个,多的排队,满了不让进
滑动窗口(Sliding Window):
- 统计最近 N 秒内的请求数
- 超过阈值则拒绝
- 精确统计,但内存消耗大
类比:电梯限重 1000kg,实时称重,超了报警
3. 代码示例:令牌桶
package ratelimit
import (
"sync"
"time"
)
// TokenBucket 令牌桶
type TokenBucket struct {
rate float64 // 每秒产生令牌数
capacity float64 // 桶容量
tokens float64 // 当前令牌数
lastUpdate time.Time // 上次更新时间
mu sync.Mutex
}
func NewTokenBucket(rate, capacity float64) *TokenBucket {
return &TokenBucket{
rate: rate,
capacity: capacity,
tokens: capacity, // 初始满桶
lastUpdate: time.Now(),
}
}
func (tb *TokenBucket) Allow() bool {
tb.mu.Lock()
defer tb.mu.Unlock()
now := time.Now()
elapsed := now.Sub(tb.lastUpdate).Seconds()
tb.lastUpdate = now
// 补充令牌
tb.tokens += elapsed * tb.rate
if tb.tokens > tb.capacity {
tb.tokens = tb.capacity
}
if tb.tokens >= 1 {
tb.tokens--
return true
}
return false
}4. 代码示例:滑动窗口(Redis 实现)
// 基于 Redis ZSet 的滑动窗口限流
func (r *RedisRateLimiter) Allow(ctx context.Context, key string, limit int, window time.Duration) bool {
now := time.Now().UnixMilli()
windowStart := now - window.Milliseconds()
pipe := r.client.Pipeline()
// 1. 移除窗口外的旧记录
pipe.ZRemRangeByScore(ctx, key, "0", strconv.FormatInt(windowStart, 10))
// 2. 添加当前请求
pipe.ZAdd(ctx, key, redis.Z{Score: float64(now), Member: now})
// 3. 统计窗口内请求数
countCmd := pipe.ZCard(ctx, key)
// 4. 设置过期时间
pipe.Expire(ctx, key, window)
_, err := pipe.Exec(ctx)
if err != nil {
return false // 保守策略:Redis 异常时拒绝
}
return countCmd.Val() <= int64(limit)
}5. 方案对比
| 算法 | 突发流量 | 平滑性 | 精度 | 实现复杂度 | 适用场景 |
|---|---|---|---|---|---|
| 令牌桶 | 允许 | 中 | 中 | 低 | API 网关、通用限流 |
| 漏桶 | 不允许 | 高 | 中 | 低 | 下游保护、队列消费 |
| 滑动窗口 | 取决于窗口 | 中 | 高 | 中 | 精确计数、熔断触发 |
| 滑动日志 | 不允许 | 高 | 极高 | 高 | 计费、审计 |
6. 常见误区
❌ 误区:"限流就是每秒固定 QPS。" ✅ 正解:限流策略应根据业务特点选择:突发型业务用令牌桶,平滑型用漏桶,计费用滑动窗口。
❌ 误区:"限流阈值设得越高越好。" ✅ 正解:阈值应基于压测数据,通常设置为系统容量的 70%~80%,留有余量应对突发。
7. 延伸问题
- "分布式限流怎么实现?"
- "限流和熔断的区别是什么?"
- "如果 Redis 限流挂了怎么办?"
6.2 熔断(Circuit Breaker)
TL;DR
熔断是系统的保险丝:错误率超过阈值时快速失败,防止故障扩散,定期探测恢复。
1. 场景与背景
- "如果下游服务挂了,怎么防止拖垮整个系统?"
- "熔断器和降级有什么区别?"
2. 状态机
+-----------+
| CLOSED | <-- 正常状态,请求通过
| (关闭) |
+----+------+
| 错误率超过阈值
v
+-----------+
| OPEN | <-- 熔断状态,请求快速失败
| (打开) |
+----+------+
| 超时后
v
+-----------+
| HALF-OPEN | <-- 探测状态,放行少量请求测试
| (半开) |
+----+------+
| 探测成功
+-------> CLOSED
| 探测失败
+-------> OPEN
3. 代码示例
package circuitbreaker
import (
"errors"
"sync"
"sync/atomic"
"time"
)
type State int32
const (
StateClosed State = iota // 正常
StateOpen // 熔断
StateHalfOpen // 半开探测
)
type CircuitBreaker struct {
failureThreshold int32 // 熔断阈值(连续失败次数)
successThreshold int32 // 恢复阈值(半开时连续成功次数)
timeout time.Duration // 熔断后等待时间
state atomic.Int32
failures atomic.Int32
successes atomic.Int32
lastFailure atomic.Int64 // 时间戳
mu sync.RWMutex
}
func (cb *CircuitBreaker) Call(fn func() error) error {
state := State(cb.state.Load())
switch state {
case StateOpen:
// 检查是否过了冷却期
if time.Since(time.Unix(0, cb.lastFailure.Load())) > cb.timeout {
cb.setState(StateHalfOpen)
cb.failures.Store(0)
cb.successes.Store(0)
} else {
return errors.New("circuit breaker is open")
}
}
err := fn()
cb.recordResult(err)
return err
}
func (cb *CircuitBreaker) recordResult(err error) {
if err != nil {
cb.failures.Add(1)
cb.successes.Store(0)
cb.lastFailure.Store(time.Now().UnixNano())
if cb.failures.Load() >= cb.failureThreshold {
cb.setState(StateOpen)
}
} else {
cb.successes.Add(1)
if State(cb.state.Load()) == StateHalfOpen && cb.successes.Load() >= cb.successThreshold {
cb.setState(StateClosed)
cb.failures.Store(0)
}
}
}
func (cb *CircuitBreaker) setState(s State) {
cb.state.Store(int32(s))
}4. 业界实践
Netflix Hystrix:
- 基于错误率(默认 50%)和请求量(默认 20 请求/秒)触发熔断。
- 半开状态每 5 秒放 1 个请求探测。
阿里巴巴 Sentinel:
- 支持慢调用比例、异常比例、异常数三种熔断策略。
- 与限流、系统保护、热点防护形成完整防护体系。
5. 常见误区
❌ 误区:"熔断后所有请求都拒绝。" ✅ 正解:熔断后进入快速失败,但会定期探测(半开状态),成功后自动恢复。
❌ 误区:"熔断阈值越低越好。" ✅ 正解:阈值太低导致频繁熔断影响正常业务,太高则失去保护作用。通常错误率阈值设为 50%~80%。
6. 延伸问题
- "熔断和降级的区别和联系?"
- "Hystrix 的线程隔离和信号量隔离怎么选?"
- "怎么防止熔断器本身成为瓶颈?"
6.3 降级策略
TL;DR
降级是牺牲非核心功能保全核心功能:预案前置、开关可控、灰度执行。
1. 降级 vs 熔断
| 维度 | 熔断 | 降级 |
|---|---|---|
| 触发时机 | 被动(错误率超标) | 主动(预案执行)或被动(熔断触发) |
| 目标 | 防止故障扩散 | 保证核心功能可用 |
| 实现 | 框架层面(Hystrix/Sentinel) | 业务层面(预案代码) |
| 恢复 | 自动探测恢复 | 人工或定时恢复 |
2. 降级策略分级
L1 - 页面降级:关闭非核心页面元素(推荐商品、历史记录)
L2 - 服务降级:关闭非核心服务(商品评价、物流轨迹)
L3 - 数据降级:返回缓存数据或默认值
L4 - 功能降级:关闭写功能,只保留读
L5 - 全站降级:静态化展示,停止动态交互
3. 代码示例:多级降级
package degrade
// 商品详情页降级策略
func (s *ProductService) GetDetail(ctx context.Context, productID string) (*ProductDetail, error) {
// 正常路径
detail, err := s.getDetailNormal(ctx, productID)
if err == nil {
return detail, nil
}
// L1: 服务熔断时,走降级路径
if errors.Is(err, ErrCircuitOpen) {
return s.getDetailDegraded(ctx, productID)
}
return nil, err
}
// 降级路径:只返回核心信息
func (s *ProductService) getDetailDegraded(ctx context.Context, productID string) (*ProductDetail, error) {
// 1. 从本地缓存读取基础信息
detail, err := s.localCache.Get(productID)
if err == nil {
// 降级:关闭推荐、评价、库存实时查询
detail.Recommendations = nil
detail.Reviews = nil
detail.Stock = -1 // 未知
return detail, nil
}
// 2. 缓存也没有,返回静态兜底页
return s.getStaticFallback(productID), nil
}4. 延伸问题
- "降级开关怎么设计?"
- "降级和熔断的触发顺序是什么?"
- "怎么演练降级预案?"
7. 负载均衡与流量调度
7.1 负载均衡算法
TL;DR
负载均衡是分布式系统的流量调度器:轮询简单公平,加权轮询按容量分配,最小连接适应长连接,一致性 Hash 保证会话粘性。
1. 算法对比
| 算法 | 原理 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| Round Robin | 依次分发 | 简单公平 | 无视服务器性能差异 | 同构服务 |
| Weighted RR | 按权重分发 | 考虑服务器容量 | 权重配置麻烦 | 异构集群 |
| Least Connections | 分给连接数最少的 | 适应长连接 | 需要实时统计 | WebSocket、数据库 |
| IP Hash | hash(client_ip) | 会话保持 | 不均匀 | 有状态服务 |
| Consistent Hash | hash(key) 映射环 | 节点增减影响小 | 实现复杂 | 缓存分片 |
| Adaptive | 根据 RT/成功率动态调整 | 自适应 | 复杂,有滞后 | 大规模微服务 |
2. 代码示例:加权轮询(平滑加权)
package loadbalance
// SmoothWeightedRoundRobin 平滑加权轮询(Nginx 算法)
type SmoothWRR struct {
nodes []*Node
}
type Node struct {
Addr string
Weight int // 配置权重
CurrentWeight int // 当前权重(动态)
}
func (sw *SmoothWRR) Pick() *Node {
var best *Node
total := 0
for _, node := range sw.nodes {
node.CurrentWeight += node.Weight
total += node.Weight
if best == nil || node.CurrentWeight > best.CurrentWeight {
best = node
}
}
if best != nil {
best.CurrentWeight -= total
}
return best
}3. 延伸问题
- "L4 负载均衡和 L7 负载均衡的区别?"
- "为什么 Nginx 使用平滑加权轮询而不是普通加权轮询?"
- "微服务中 Client-Side LB(如 Ribbon)vs Server-Side LB 怎么选?"
8. 分布式 ID 生成
8.1 方案全景
TL;DR
分布式 ID 要求全局唯一、趋势递增、高性能;Snowflake 是最主流方案,号段模式(Leaf)解决时钟回拨,UUID 只适合日志追踪。
1. 方案对比
| 方案 | 结构 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| UUID | 128bit 随机 | 本地生成,无依赖 | 无序、存储大、索引性能差 | 日志 TraceID |
| Snowflake | 64bit (时间戳+机器ID+序列号) | 趋势递增、高性能 | 依赖时钟、需要分配机器ID | 订单ID、消息ID |
| 号段模式 | 从 DB 批量获取号段 | 性能高(内存分配) | 依赖 DB、号段用完需阻塞获取 | 美团 Leaf |
| Leaf-Snowflake | Snowflake + ZooKeeper 分配机器ID | 解决时钟回拨 | 依赖 ZK | 美团开源方案 |
2. Snowflake 详解
Snowflake 64bit 结构:
| 1 bit | 41 bits | 10 bits | 12 bits |
| 符号位 | 时间戳差值 | 机器/数据中心ID | 序列号 |
| 0 | 毫秒级时间戳 | workerId | 同一毫秒内递增 |
- 时间戳:从自定义起始时间(如 2020-01-01)计算的毫秒数
- 41 bit 时间戳 ≈ 69 年
- 10 bit workerId = 1024 个节点
- 12 bit 序列号 = 每节点每毫秒 4096 个 ID
3. 代码示例:Snowflake(Go)
package snowflake
import (
"errors"
"sync"
"time"
)
const (
workerBits uint8 = 10 // 机器 ID 位数
numberBits uint8 = 12 // 序列号位数
workerMax int64 = -1 ^ (-1 << workerBits)
numberMax int64 = -1 ^ (-1 << numberBits)
timeShift uint8 = workerBits + numberBits
workerShift uint8 = numberBits
startTime int64 = 1577836800000 // 2020-01-01 00:00:00
)
type Worker struct {
mu sync.Mutex
timestamp int64
workerId int64
number int64
}
func NewWorker(workerId int64) (*Worker, error) {
if workerId < 0 || workerId > workerMax {
return nil, errors.New("worker ID out of range")
}
return &Worker{workerId: workerId}, nil
}
func (w *Worker) GetId() int64 {
w.mu.Lock()
defer w.mu.Unlock()
now := time.Now().UnixMilli()
if w.timestamp == now {
w.number++
if w.number > numberMax {
// 当前毫秒序列号用完,等待下一毫秒
for now <= w.timestamp {
now = time.Now().UnixMilli()
}
}
} else {
w.number = 0
w.timestamp = now
}
id := (now-startTime)<<timeShift | (w.workerId << workerShift) | w.number
return id
}4. 时钟回拨问题
问题:NTP 同步或手动调整导致系统时间回退,可能生成重复 ID。
解法:
- 等待:记录上次生成时间,回拨时阻塞等待(简单但影响性能)。
- 序列号扩展:使用预留位扩展序列号容量。
- Leaf-Snowflake:美团方案,用 ZooKeeper 检测时钟回拨,超过阈值报警。
5. 号段模式(Leaf-Segment)
// 号段分配器:从数据库批量获取号段,内存中分配
package leaf
type Segment struct {
current int64 // 当前已分配
max int64 // 号段上限
step int64 // 步长
}
func (s *Segment) GetID() (int64, error) {
id := atomic.AddInt64(&s.current, 1)
if id > s.max {
return 0, errors.New("segment exhausted")
}
return id, nil
}
// 双 Buffer 优化:一个号段用完 10% 时,异步获取下一段
func (a *Allocator) GetID() (int64, error) {
for {
// 尝试从当前段分配
if id, err := a.current.GetID(); err == nil {
// 触发异步加载下一段(如果快用完)
if a.current.max-id < a.current.step/10 {
a.asyncLoadNext()
}
return id, nil
}
// 当前段用完,切换到预备段
a.mu.Lock()
if a.next.ready {
a.current = a.next.segment
a.next.ready = false
a.mu.Unlock()
continue
}
a.mu.Unlock()
// 等待加载完成
time.Sleep(10 * time.Millisecond)
}
}6. 常见误区
❌ 误区:"UUID 适合做主键。" ✅ 正解:UUID 无序导致 B+ 树频繁分裂,索引性能差;且占用空间大(16 字节 vs 8 字节)。推荐 Snowflake。
❌ 误区:"Snowflake 的 workerId 可以随机分配。" ✅ 正解:workerId 必须全局唯一,通常通过 ZooKeeper/etcd 分配,或配置中心统一下发。
7. 延伸问题
- "Snowflake 的 41 位时间戳用完了怎么办?"
- "怎么保证 Snowflake 在 K8s 环境中 workerId 唯一?"
- "号段模式和 Snowflake 怎么选?"
附录:面试高频问题速查
分布式理论
- CAP 中 P 为什么必须满足?
- BASE 理论和 ACID 的本质区别?
- PACELC 定理解决了 CAP 的什么问题?
一致性
- 线性一致和顺序一致的区别?
- 一致性 Hash 虚拟节点的作用?如果不使用会怎样?
- 数据分片后怎么保证跨分片事务?
分布式锁
- Redis 单节点锁的主从延迟问题怎么解决?
- RedLock 的时钟漂移问题怎么避免?
- ZooKeeper 和 etcd 做分布式锁的优劣势?
- 分布式锁的可重入怎么实现?
分布式事务
- 2PC 的同步阻塞问题怎么优化?
- TCC 的悬挂、空回滚、幂等分别怎么解决?
- Saga 模式的补偿失败怎么处理?
- Seata AT 模式的 UNDO_LOG 是怎么生成的?
- 本地消息表方案和最大努力通知的区别?
一致性协议
- Raft 选举时如果平票怎么办?
- Raft 的日志压缩(Snapshot)是怎么做的?
- Raft 和 Paxos 的最核心区别是什么?
- Multi-Raft 解决了单 Raft 的什么问题?
- ZooKeeper 的 ZAB 和 Raft 有什么区别?
稳定性
- 令牌桶和漏桶的本质区别?分别适合什么场景?
- 分布式限流怎么实现?
- 熔断器的三个状态和转换条件?
- 降级和熔断的区别?实际项目中怎么配合使用?
负载均衡与 ID
- Nginx 平滑加权轮询算法原理?
- L4 和 L7 负载均衡的区别?
- Snowflake 时钟回拨问题怎么解决?
- 号段模式的双 Buffer 优化是什么?
关联知识
- 21-golang-core-interview-k2.6.md — Go 语言核心面试
- 20-spring-cloud-alibaba-core-interview-k2.6.md — 微服务框架面试
- 18-kafka-rocketmq-core-interview-k2.6.md — 消息队列面试
- 17-mysql-postgresql-core-interview-k2.6.md — 数据库面试