
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:18 题
核心主题:分布式锁(Redlock/Redisson/ZK)、Redis 高可用(主从/哨兵/Cluster)、缓存策略(三穿/双层/热Key)
Q1:Redis 分布式锁(RedLock / Redisson / SETNX)
TL;DR
分布式锁演进:SETNX(最简陋,无超时)→ SET NX PX(带超时,但可能误删)→ Redisson(看门狗自动续期 + 可重入 + Lua 原子释放)→ RedLock(多节点投票,防单点故障但争议大)。
类比
🔑 酒店房卡:SETNX = 拿钥匙开门,但忘了还就永远锁着。SET NX PX = 房卡 30 分钟过期,但你还在房里就被赶出来。Redisson = 智能房卡,你在房里自动续期,退房自动释放。RedLock = 酒店有 5 个前台,3 个以上说"房空着"才算真空。
演进对比
| 方案 | 命令 | 问题 | 解决 |
|---|---|---|---|
| SETNX | SETNX lock:key 1 | 没超时→死锁 | — |
| SET NX PX | SET lock:key val NX PX 30000 | 业务超时→锁过期被他人获取→误删 | value 用唯一 ID 校验 |
| Redisson | 看门狗定时续期 | — | 生产首选 |
| RedLock | 多节点多数派 | 性能差,争议大 | 极端场景才用 |
Redisson 看门狗
// Redisson 自动续期机制
RLock lock = redisson.getLock("lock:order:123");
// 加锁(默认 30s 超时,看门狗每 10s 续期到 30s)
lock.lock();
try {
// 业务逻辑(即使执行 5 分钟,锁也不会过期)
processOrder();
} finally {
// 释放时校验:确保是自己加的锁(Lua 原子)
lock.unlock();
}
// 看门狗原理:
// 1. 加锁成功 → 启动定时任务(每 internalLockLeaseTime/3 续期)
// 2. 续期:if (redis.call('hexists', KEYS[1], ARGV[2]) == 1)
// then redis.call('pexpire', KEYS[1], ARGV[1]);
// 3. 释放时停止定时任务Lua 原子释放(防止误删)
-- 只有 value 匹配才删除(防止删了别人的锁)
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end记忆锚
"SETNX 会死锁,SET NX PX 会误删,Redisson 看门狗是生产标配"
Q2:Redis 主从切换瞬间如何避免分布式锁失效?
TL;DR
主从切换丢锁 = 主节点加锁成功 → 主宕机 → 锁数据还没同步到从节点 → 从提升为主 → 锁丢失 → 另一个客户端能加同一把锁。解决:RedLock(多节点多数派)或 fencing token(单调递增序号防旧写)。
类比
🏨 酒店前台换班:你在前台 A 登记入住(加锁),前台 A 突然晕倒,前台 B 接班。但 B 的登记本上没你的记录(主从延迟)→ B 把同一间房又开给了别人。
问题图解
解决方案
方案 1:RedLock(多数派)
不是单节点加锁,而是向 5 个独立 Redis 节点依次加锁
→ 至少 3 个节点加锁成功 → 才算获取锁成功
→ 一个节点故障不影响整体
缺点:性能差(N 次网络往返),业界争议大(Martin Kleppmann 批评)
方案 2:Fencing Token(推荐)
每次加锁成功 → 返回一个单调递增的 token(如 33)
操作数据时附带 token → 存储层拒绝更小 token 的写入
→ 即使锁被重复获取,旧 token 的写入会被拒绝
实现:ZooKeeper zxid / etcd revision / Redis INCR
记忆锚
"主从异步复制是根源→RedLock 多节点投票→Fencing Token 拒旧写"
Q3:Redis 集群主节点宕机,从节点提升的问题和应对
TL;DR
主节点宕机 → Sentinel 选举新主。问题:数据丢失窗口(主宕机前未同步到从的数据永久丢失)+ 脑裂(网络分区导致两个主)。应对:min-replicas-to-write + min-replicas-max-lag 限制写入。
丢失窗口
主节点写入 → 异步复制到从 → 从确认
↑
如果主在这之前宕机 → 这期间的写入永久丢失
估算:repl-backlog-size 内的数据可能保留,之外的永久丢失
应对配置
# 至少 1 个从节点确认才写入(牺牲可用性换一致性)
min-replicas-to-write 1
min-replicas-max-lag 10 # 从节点延迟超过 10s → 主拒绝写入
# 脑裂应对:哨兵配置
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 5000
# → 至少 2 个哨兵同意才做主从切换记忆锚
"异步复制有丢失窗口→min-replicas 限写入→哨兵多数派防脑裂"
Q4:缓存三穿(穿透/击穿/雪崩)完整方案
TL;DR
穿透(查不存在的数据→打 DB)→ 布隆过滤器拦截。击穿(热点 Key 过期→大量请求打 DB)→ 互斥锁单线程查 DB。雪崩(大量 Key 同时过期→DB 瞬间高压)→ 随机 TTL。
类比
🧅 洋葱防御三层:穿透 = 有人假装送快递想进小区(查不存在的数据),门卫(布隆过滤器)直接拦。击穿 = 网红店排队(热点 Key),店员一次只放一个人进去(互斥锁)。雪崩 = 超市所有打折商品同时到期→大妈们同时冲进来→随机延后过期时间分散压力。
三穿对比
| 穿透 | 击穿 | 雪崩 | |
|---|---|---|---|
| 现象 | 查不存在的数据,缓存永远 miss | 热点 Key 过期瞬间大量请求 | 大量 Key 同时过期 |
| 攻击目标 | DB | DB | DB + Redis |
| 方案 | 布隆过滤器 + 空值缓存 | 互斥锁 + 永不过期 | 随机 TTL + 多级缓存 |
代码实现
// 1. 穿透:布隆过滤器
public Order getOrder(String orderId) {
if (!bloomFilter.mightContain(orderId)) {
return null; // 一定不存在,直接返回
}
// 可能存在于缓存或 DB
return getFromCacheOrDb(orderId);
}
// 2. 击穿:互斥锁
public Product getHotProduct(String productId) {
Product p = redis.get(productId);
if (p != null) return p;
// 只有一个线程去查 DB
String lockKey = "lock:product:" + productId;
if (redis.set(lockKey, "1", "NX", "PX", 5000)) {
try {
p = db.query(productId);
redis.set(productId, p, 60, TimeUnit.SECONDS);
} finally {
redis.del(lockKey);
}
} else {
Thread.sleep(50); // 等持有锁的线程写完缓存
return redis.get(productId);
}
return p;
}
// 3. 雪崩:随机 TTL
redis.set(key, value, 3600 + ThreadLocalRandom.current().nextInt(600), TimeUnit.SECONDS);
// → TTL = 3600~4200s,避免同时过期记忆锚
"穿透布隆拦,击穿互斥锁,雪崩随机 TTL"
Q5:双层缓存设计(内存 + Redis)
TL;DR
双层缓存 = Caffeine(JVM 本地) + Redis(分布式)。本地缓存极快(纳秒级)但不同步,Redis 较慢(毫秒级)但全局一致。核心问题:两层之间的数据一致性如何保证。
类比
🏠 家里冰箱 + 楼下超市:本地缓存 = 冰箱(拿东西秒级,但每家冰箱内容不同)。Redis = 楼下超市(东西多,走几分钟,所有人看到的库存一样)。通常先翻冰箱,没找到再去超市。
架构
public Data getData(String key) {
// L1:本地缓存(Caffeine,纳秒级)
Data data = caffeineCache.getIfPresent(key);
if (data != null) return data;
// L2:Redis(毫秒级)
data = redis.get(key);
if (data != null) {
caffeineCache.put(key, data); // 回填 L1
return data;
}
// L3:DB
data = db.query(key);
redis.set(key, data, ttl);
caffeineCache.put(key, data);
return data;
}一致性问题 + 解决
问题:A 实例修改了 Redis → B 实例的本地缓存还是旧数据
方案 1(推荐):Redis Pub/Sub 通知失效
→ 修改 Redis → 发布消息 "key:xxx 已更新"
→ 所有实例收到 → 删除本地缓存中的 key
→ 实现:Redis Pub/Sub 或 Kafka 广播
方案 2:短 TTL 兜底
→ 本地缓存 TTL 设短(如 5 秒)
→ 5 秒后自动过期,下次从 Redis 拉新数据
→ 简单但 5 秒内不一致
方案 3:Canal 监听 binlog
→ DB 变更 → Canal 捕获 → 通知所有实例刷新
什么场景适合双层缓存?
✅ 适合:
- 风控规则(读多写少,规则版本更新通过 Pub/Sub 通知)
- 用户画像数据(读极多,写极少)
- 币种基础信息(几乎不变)
❌ 不适合:
- 实时价格(变化太快,本地缓存延迟不可接受)
- 用户余额(必须强一致,不缓存或极短 TTL)
记忆锚
"Caffeine 求快,Redis 求准,Pub/Sub 通知求一致,短 TTL 兜底"
Q6:本地缓存技术选型
TL;DR
Java 本地缓存三选一:Caffeine(W-TinyLFU,目前最优)> Guava Cache > Ehcache。Caffeine 接近最优命中率,是 Spring Boot 默认的缓存实现。
对比
| Caffeine | Guava Cache | Ehcache | |
|---|---|---|---|
| 淘汰算法 | W-TinyLFU(最优) | LRU | LRU / LFU / FIFO |
| 性能 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
| Spring 集成 | ✅ 原生支持 | ✅ | ✅ |
| 持久化 | ❌ 纯内存 | ❌ 纯内存 | ✅ 支持磁盘 |
| 活跃度 | 活跃(Caffeine 2.x) | 维护模式 | 活跃(Ehcache 3.x) |
Caffeine 配置
Cache<String, Object> cache = Caffeine.newBuilder()
.maximumSize(10_000) // 最多 1 万条
.expireAfterWrite(60, TimeUnit.SECONDS) // 写后 60s 过期
.expireAfterAccess(30, TimeUnit.SECONDS) // 30s 无访问过期
.recordStats() // 开启统计
.build();记忆锚
"Caffeine 最先进(W-TinyLFU),Guava 够用,Ehcache 要持久化才选"
Q7:Redis 持久化 RDB vs AOF
TL;DR
RDB = 定时快照(二进制,恢复快,可能丢数据)。AOF = 写命令日志(文本,数据安全,恢复慢)。交易系统推荐:RDB + AOF 混合(Redis 4.0+),RDB 做快速恢复,AOF 补全快照后的增量。
对比
| RDB | AOF | |
|---|---|---|
| 原理 | fork 子进程把内存快照写到磁盘 | 每条写命令追加到 AOF 文件 |
| 文件大小 | 小(压缩的二进制) | 大(文本命令) |
| 恢复速度 | 快(直接加载) | 慢(逐条重放命令) |
| 数据安全 | 可能丢失最后一次快照后的数据 | 高(可配置每次写刷盘) |
| 性能影响 | fork 时短暂阻塞 | 持续轻微影响 |
| 交易系统推荐 | 作为快速恢复的基底 | AOF 补全 RDB 快照后的数据 |
混合持久化(Redis 4.0+)
aof-use-rdb-preamble yes
原理:
AOF 文件前半部分 = RDB 格式快照(加载快)
AOF 文件后半部分 = AOF 增量命令(安全)
重启时:先加载 RDB 部分(秒级恢复)→ 再重放增量 AOF(补全数据)
记忆锚
"RDB 快恢复,AOF 保安全,混合持久化两者兼得——交易系统标配"
Q8:Redis 集群模式对比
TL;DR
三种模式:主从(最简单,手动切换)→ 哨兵 Sentinel(自动故障转移,但仍是单主写入)→ Cluster(数据分片,多主写入,真正分布式)。
对比
| 主从 | 哨兵 Sentinel | Cluster | |
|---|---|---|---|
| 数据分片 | ❌ 无 | ❌ 无 | ✅ 16384 哈希槽 |
| 故障转移 | 手动 | 自动 | 自动 |
| 可写节点 | 仅主节点 | 仅主节点 | 多个主节点 |
| 最大容量 | 单机内存 | 单机内存 | N × 单机内存 |
| 复杂度 | ⭐ | ⭐⭐ | ⭐⭐⭐⭐ |
| 适用 | 开发环境 | 生产环境中小规模 | 大规模生产 |
哨兵核心机制
1. 监控:Sentinel 定期 PING 主节点
2. 主观下线(SDOWN):一个 Sentinel 认为主挂了
3. 客观下线(ODOWN):多数(≥ quorum)Sentinel 认为挂了
4. 选举 Leader Sentinel:由 Leader 执行故障转移
5. 故障转移:选新主 + 通知客户端
Cluster 哈希槽
16384 个槽 → 均匀分布到 N 个主节点
key → CRC16(key) % 16384 → 槽号 → 路由到对应节点
扩缩容:迁移部分槽(不是所有 key 重新 hash!)
→ 比一致性哈希更简单、更高效
记忆锚
"主从手动切,哨兵自动切但单主写,Cluster 多主写 + 哈希槽分片"
Q9:Redis 数据结构底层原理
TL;DR
Redis 五大数据类型底层实现:String = SDS(简单动态字符串)、List = Quicklist(双向链表+压缩列表)、Hash = ziplist→hashtable、Set = intset→hashtable、ZSet = ziplist→skiplist+hashtable。核心优化:小数据用紧凑结构(ziplist/intset),大数据切换为标准结构。
底层映射
| 数据类型 | 小数据编码 | 大数据编码 | 切换阈值 |
|---|---|---|---|
| String | raw / embstr | raw | — |
| List | quicklist | quicklist | — |
| Hash | ziplist | hashtable | hash-max-ziplist-entries=512 |
| Set | intset | hashtable | set-max-intset-entries=512 |
| ZSet | ziplist | skiplist + dict | zset-max-ziplist-entries=128 |
ZSet 为什么用跳表?
跳表(SkipList):
- 多层索引,查找 O(logN)
- 插入 O(logN)(概率均衡,不需要旋转)
- 实现简单(比红黑树少很多代码)
- 天然支持范围查询(ZRANGE)
红黑树也能做,但:
- 实现复杂(旋转/变色)
- 范围查询需要中序遍历
→ 跳表是 ZSet 的最优选择
记忆锚
"小数据用紧凑结构省内存,大数据切标准结构追求性能"
Q10:Redis 大 Key 与热 Key 治理
TL;DR
大 Key = 单个 Key 的 value 过大(如哈希表 100 万字段)→ 删除阻塞 Redis → 用 UNLINK 异步删。热 Key = 单个 Key QPS 过高(如秒杀商品)→ 打散到多个 Key 或本地缓存。
大 Key 问题
大 Key = 单个 value > 10MB 或 集合元素 > 10 万
危害:
1. 读取慢(网络传输 10MB+)
2. 删除阻塞(DEL 命令 O(N),10 万元素删 1 秒)
3. 迁移慢(Cluster 迁移槽时卡住)
发现:redis-cli --bigkeys / MEMORY USAGE key
解决:
- 拆分:user:123:profile → user:123:name, user:123:avatar...
- 异步删除:UNLINK key(Redis 4.0+,后台线程删)
- 清理:SCAN + UNLINK 批量清理
热 Key 问题
热 Key = 单个 Key QPS > 10000(如爆款商品库存)
危害:
1. 单节点 CPU 打满(所有请求打到同一节点)
2. 带宽瓶颈(所有网卡流量集中)
解决:
1. 打散:stock:item:123 → stock:item:123:seg1 ~ seg10(分段库存)
2. 本地缓存:Caffeine 缓存热点数据,1s 刷新一次
3. 读写分离:热 Key 的读请求走从节点
记忆锚
"大 Key UNLINK 异步删,热 Key 打散分段 + 本地缓存"
Q11:分布式锁续期(看门狗)和锁误删
TL;DR
锁续期 = Redisson 看门狗定时延长锁过期时间(默认每 10s 续期到 30s)。锁误删 = A 的业务超时锁自动过期 → B 获取锁 → A 释放时把 B 的锁删了 → 用唯一 value(UUID)校验,只删自己的锁。
锁误删场景
防止误删:Lua 原子校验
-- key 存在且 value 是自己的 UUID 才删除
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end记忆锚
"续期靠看门狗,防误删靠 UUID + Lua 原子校验"
Q12:设计一个简单的分布式锁服务
TL;DR
最小分布式锁 = 加锁(SET NX PX + UUID)→ 释放(Lua 校验 UUID 后 DEL)→ 续期(定时任务延长过期时间)→ 极端情况:网络分区时需用 fencing token 防旧写。
口述架构
1. 加锁:
SET lock:resource:1 {uuid} NX PX 30000
→ NX:仅当不存在才成功(互斥)
→ PX 30000:30 秒自动过期(防死锁)
→ uuid:释放时校验身份(防误删)
2. 释放:
Lua:if get == myUUID then DEL
→ 原子操作,不会误删别人的锁
3. 续期:
后台线程每 10s 执行:if get == myUUID then PEXPIRE 30000
→ 业务没执行完,锁不会过期
4. 可重入:
Hash 结构:HINCRBY lock:key {uuid}:count 1
→ 同一线程可多次获取,count 计数
5. 极端情况(网络分区):
客户端 A 被分区 → 锁过期 → 客户端 B 获取锁
→ A 恢复后仍认为自己有锁 → 数据错乱
→ 解决:fencing token(存储层拒绝旧 token 的写入)
记忆锚
"SET NX PX 加锁 → Lua UUID 校验释放 → 定时续期 → fencing token 防分区"
Q13:分布式锁——Redis vs Etcd
TL;DR
Redis = 高性能(AP 模型),适合性能敏感但对一致性格外要求不极端的场景。Etcd/ZooKeeper = 强一致(CP 模型),适合对一致性要求极高的场景(如选主)。交易所资产锁推荐 Etcd。
对比
| Redis(RedLock/Redisson) | Etcd / ZooKeeper | |
|---|---|---|
| CAP | AP(优先可用性) | CP(优先一致性) |
| 一致性 | 最终一致(主从异步) | 强一致(Raft 多数派) |
| 性能 | ⭐⭐⭐⭐⭐(内存级) | ⭐⭐⭐(需 Raft 共识) |
| 锁续期 | 看门狗自动续期 | Lease 自动续约 |
| 死锁处理 | TTL 过期自动释放 | Session 断开自动释放 |
| 适用 | 高频低延迟场景 | 资产/选主/配置锁 |
选型建议
风控规则热更新锁 → Redis(高频,锁持有时间短)
用户资产冻结锁 → Etcd(强一致,钱不能错)
分布式定时任务选主 → Etcd(必须 CP)
秒杀库存扣减锁 → Redis(高性能)
记忆锚
"Redis 快但不完全准,Etcd 准但不快——钱的事用 Etcd,性能的事用 Redis"
Q14:Redis 集群为什么用哈希槽而非一致性哈希?
TL;DR
哈希槽(16384 个槽)比一致性哈希好在:扩缩容只迁移部分槽(而非重算全部 key)、客户端缓存槽映射(一次知道去哪个节点)、槽范围绑定(节点负责连续槽号,管理简单)。
对比
| 一致性哈希 | 哈希槽(Cluster) | |
|---|---|---|
| 分片粒度 | 一个节点负责一个弧段 | 一个节点负责多个不连续槽 |
| 扩缩容 | 只影响相邻节点 | 任意节点间迁移槽 |
| 客户端路由 | 需额外维护虚拟节点映射 | 直接计算 CRC16(key) % 16384 |
| 槽数 | 理论上无限(虚拟节点) | 16384 个(足够大,心跳包小) |
为什么是 16384?
1. 心跳包大小合理:每个槽占 1 bit(共 2048 字节),16k 个槽刚好
2. 足够大:单集群最多 1000 个节点,每个节点平均 16 个槽
3. 不是越大越好:65536 个槽 → 心跳包 8KB → 太大了
记忆锚
"槽不连续分配→扩缩容灵活→客户端 CRC16 直接算→16384 是心跳包最优数"
Q15:Redis 实现复杂数据结构案例
TL;DR
Redis 不仅是 KV 缓存。ZSet 可以做延迟队列(score=执行时间戳)、频控计数器(score=时间窗口内计数)、时间线(score=时间戳)。BitMap 可以做签到统计、用户在线状态。
案例:ZSet 实现延迟队列
// 生产者:添加延迟任务
redis.zadd("delay:queue", System.currentTimeMillis() + 5000, taskId);
// 消费者:取出到期的任务
Set<String> tasks = redis.zrangeByScore("delay:queue", 0, System.currentTimeMillis());
for (String taskId : tasks) {
// 原子移除并处理
if (redis.zrem("delay:queue", taskId) > 0) {
executeTask(taskId);
}
}案例:BitMap 实现签到统计
// 用户 1001 在 2025 年第 100 天签到
redis.setbit("sign:2025:1001", 100, 1);
// 统计该用户今年签到天数
long count = redis.bitcount("sign:2025:1001");
// 统计今天签到总人数
redis.bitop("AND", "sign:today:all", "sign:2025:*");记忆锚
"ZSet 做延迟队列,BitMap 做签到——Redis 远不止缓存"
Q16:热点数据防止缓存击穿——除了互斥锁还有什么方案?
TL;DR
三种方案从快到"绝":互斥锁(标准方案)→ 永不过期 + 异步更新(零击穿)→ 逻辑过期 + 后台线程(不阻塞用户)。
方案对比
| 方案 | 原理 | 击穿风险 | 实时性 | 复杂度 |
|---|---|---|---|---|
| 互斥锁 | 单线程查 DB | 有(锁等待) | 好 | ⭐ |
| 永不过期 | 不设 TTL,异步更新 | 零 | 差 | ⭐⭐ |
| 逻辑过期 | value 含 expireTime,后台更新 | 零 | 好 | ⭐⭐⭐ |
推荐方案:逻辑过期
// 缓存值包装
class CacheData<T> {
T data;
long expireAt; // 逻辑过期时间
}
public Product getProduct(String id) {
CacheData<Product> cache = redis.get(id);
if (cache == null) {
return loadFromDb(id); // 真的 miss
}
if (cache.expireAt > System.currentTimeMillis()) {
return cache.data; // 未过期,直接返回
}
// 逻辑过期 → 先返回旧数据,后台异步更新
executor.submit(() -> {
if (redis.setnx("lock:refresh:" + id, "1", 10)) {
Product newData = db.query(id);
redis.set(id, new CacheData<>(newData, now + 30000));
redis.del("lock:refresh:" + id);
}
});
return cache.data; // 返回旧数据(不阻塞用户!)
}记忆锚
"互斥锁兜底,逻辑过期最优——返回旧数据不阻塞,后台悄悄刷新"
Q17:缓存与数据库一致性 → 详见 B5 Q1
双归 B5+B6。此处强调:Cache Aside + 延时双删是标准答案,面试时不要扯 CDC 除非面试官追问。
Q18:热点库存秒杀设计
TL;DR
库存秒杀 = Redis 分段库存(分 10 个 Key 分散压力)+ Lua 原子预减 + MQ 异步下单 + DB 最终扣减 + 对账。详见 B1 Q1 秒杀系统。
核心链路
1. Redis 分段 DECR(Lua 原子)→ 库存预减
2. 扣减成功 → MQ → 异步创建订单
3. DB 最终扣减 + 唯一索引防超卖
4. 定时对账(Redis vs DB 库存数)
记忆锚
"分段库存 + Lua 原子 + 异步下单 + 对账兜底"
总结
分布式锁 → Redisson 看门狗 > SET NX PX
锁失效 → Fencing Token 防旧写 > RedLock 多数派
缓存三穿 → 布隆/互斥锁/随机 TTL
双层缓存 → Caffeine + Redis + Pub/Sub 通知
Redis HA → 哨兵自动切(中小规模)/ Cluster 分片(大规模)
持久化 → RDB + AOF 混合(交易标配)
热 Key → 分段 + 本地缓存
B6 补充:ConsistentHash 扩缩容(Q19)
Q19:ConsistentHash 扩缩容怎么处理?
TL;DR
一致性哈希 = hash 值映射到一个环上,节点负责环上一段区间。扩容:新节点插入环 → 只影响相邻节点 → 只需迁移相邻节点的部分数据(不是全量 rehash)。这就是比取模 hash 更优的地方。
类比
⭕ 圆桌分蛋糕:取模 hash = 把圆桌切成 N 等份,增加一个人(N+1)整个圆桌重新分→所有蛋糕搬家。一致性哈希 = 圆桌是固定的,每个人管一段弧。新人来了→只从他相邻的那段弧上切走一小块→其他蛋糕不动。
虚拟节点
问题:节点少时,数据倾斜(有的节点管大片弧,有的只负责一小段)
解决:每个物理节点对应 N 个虚拟节点(如 150 个),均匀分布在环上
→ 物理节点 A → 虚拟节点 A0, A1, A2...A149
→ 虚拟节点越多 → 分布越均匀 → 数据越均衡
记忆锚
"取模 hash = 全量搬家,一致性哈希 = 只搬邻居。虚拟节点解倾斜"
下一篇:B7 Kafka / RocketMQ 消息队列深度(18 题)