
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
目标岗位:大型加密货币交易所 · 后端(风控方向)
题目数:35 题,分为 4 个板块
核心方法论:4S 分析法(Scenario → Service → Storage → Scale)+ 面试开场对齐话术
记忆原则:每道题给类比 + 关键数字 + 一张架构图 + 一个常见误区
面试开场对齐话术(所有系统设计题通用)
"好的。在画框图之前,我先快速对齐一下问题范围。
我们要做的是 [系统名],
服务 [用户规模]。
峰值 QPS 我假设大约是 [__ 写/秒、__ 读/秒],
[关键路径] 的延迟要求是 [__ ms]。
可用性目标是 [__ 个 9]。
我的高层思路是 [一句话 pipeline]。
我会先讲数据流,再估容量,然后深入热路径。
这个范围您觉得可以吗?"
记忆锚点:4 个数字 + 1 条 pipeline + 1 个确认问题。一定要先确认范围再展开——这是 Senior 的基本素养。
板块一:通用大厂热门系统设计(Q1-Q6)
Q1:设计秒杀系统
TL;DR
秒杀系统的本质是在瞬时极高并发下,用多层防御体系保护核心库存扣减操作。核心链路:CDN 静态化 → Nginx 限流 → 业务层排队 → Redis 库存预减 → MQ 异步下单 → DB 最终扣减。
类比
🎢 迪士尼热门项目排队系统:入口限流(FastPass 预约制)→ 排队区缓冲(蛇形队列)→ 每批放 N 人(令牌桶)→ 实际乘坐(库存扣减)。没抢到 FastPass 的人连排队资格都没有(前端拦截 99% 无效流量)。
核心架构
关键设计决策
| 决策点 | 方案 | 为什么 |
|---|---|---|
| 库存扣减 | Redis Lua 原子操作 | 单线程,避免超卖;比 DB 锁快 100 倍 |
| 热点库存 | Redis 分段库存(10 段) | 避免单个 Key 热点,每段独立扣减 |
| 限流层次 | CDN → Nginx 令牌桶 → 业务信号量 | 层层拦截,保护核心链路 |
| 异步下单 | MQ 削峰填谷 | 扣减成功后异步处理,不阻塞用户 |
| 缓存多级 | 本地 Caffeine → Redis → DB | 洋葱防御——扒了一层还有一层 |
库存分段扣减(Redis Lua)
-- 关键:不是 DECR 一个 key,而是随机选一个分段 DECR
local segment = math.random(1, 10)
local key = "stock:seckill:item123:seg" .. segment
local remaining = redis.call('DECR', key)
if remaining < 0 then
redis.call('INCR', key) -- 回滚
return -1 -- 库存不足
end
return remaining
为什么要分段:单 Key 10 万 QPS 就是 Redis 极限;分 10 段后每段 1 万 QPS,总吞吐 10 万+。
超卖防护层级
第 0 层:前端按钮置灰(秒杀未开始不可点)
第 1 层:Nginx 令牌桶(QPS 限制)
第 2 层:Redis Lua 库存预减(原子操作)
第 3 层:DB 唯一索引(最终兜底)
第 4 层:对账系统(事后发现超卖自动退款)
❌ 常见误区 vs ✅ 正确做法
| ❌ 误区 | ✅ 正确做法 |
|---|---|
| "用 synchronized 锁库存" | JVM 锁只对单实例有效,集群部署必超卖 |
| "直接用 MySQL 扣库存" | MySQL 行锁 ≈ 1000 QPS,秒杀 10 万 QPS 直接打挂 |
| "Redis DECR 就够了" | 单 Key 热点问题,需分段 + Lua 原子化 |
| "先更新缓存再写库" | 秒杀场景反过来——先扣 Redis(快速判定),再异步写库 |
记忆锚
"三件套防御 + 异步化":秒杀 = 前端拦截(99%)+ Redis 分段库存(原子扣) + MQ 异步下单(不阻塞)。面试时说"我设计秒杀系统最核心的三个点是…"就够了。
Q2:设计短链接服务
TL;DR
短链接 = 发号器生成唯一 ID → Base62 编码 → 存储映射 → 302 跳转。核心挑战:发号器的高性能和高可用,布隆过滤器防止重复。
类比
📇 图书馆索书号:全名"基于深度学习的自然语言处理在金融风控中的应用研究.pdf"→ 索书号"TP183/2025"。短链接就是给长 URL 分配一个短索书号。
核心架构
关键设计决策
| 决策点 | 方案 | 为什么 |
|---|---|---|
| ID 生成 | 雪花算法(Snowflake) | 分布式唯一、趋势递增、高性能 |
| 短码转换 | Base62(0-9a-zA-Z) | 62 个字符,7 位 = 62^7 ≈ 3.5 万亿个短链 |
| 跳转方式 | 302 临时重定向 | 保留原始 URL 用于统计,301 会被浏览器缓存 |
| 防重复 | 布隆过滤器 + DB 唯一索引 | 先用 BF 判断"大概率不存在",再查 DB 精准判定 |
| 缓存 | Redis LRU | 热门短链命中率 >95% |
❌ 误区
| ❌ 误区 | ✅ 正解 |
|---|---|
| "用 URL hash 做短码" | hash 碰撞率高(MD5 截断),需冲突解决,非最佳方案 |
| "301 跳转" | 浏览器缓存 301 后不再访问短链服务,无法统计 PV |
| "只用布隆过滤器防重复" | BF 有误判率,必须 DB 唯一索引兜底 |
记忆锚
"发号 + Base62 + 302":三步走,短链接就这么简单。追问就说布隆过滤器 + 雪花算法。
Q3:设计 Feed 流 / IM 消息系统
TL;DR
Feed 流 = 推模式(写时扩散,读快)vs 拉模式(读时聚合,写快)→ 大 V 用拉、普通用户用推的推拉结合模式。
类比
📬 朋友圈 vs 微博:朋友圈是"推"——你发一条,所有好友都收到一份拷贝(写放大)。微博大 V 是"拉"——粉丝自己去大 V 主页看(读放大)。微信实际是推拉结合:普通好友推送,大 V 订阅号拉取。
核心架构决定
❌ 误区
| ❌ | ✅ |
|---|---|
| "全部推模式,简单" | 大 V 1000 万粉丝,一条消息写 1000 万次,写延迟爆炸 |
| "全部拉模式,省存储" | 拉 1000 个关注者 + 排序 + 聚合,读延迟不可接受 |
记忆锚
"大 V 拉,普通推":阈值设置(粉丝数 > 10 万→拉)。面试时直接说:我设计的是推拉结合模式,以粉丝数量为分界线。
Q4 & Q5:设计全局唯一且趋势递增的订单号生成器
TL;DR
订单号 = 雪花算法(Snowflake)作为基础,叠加业务前缀 + 分库分表路由信息。核心挑战:时钟回拨处理、分库分表场景下的全局唯一。
雪花算法结构(64 bits)
┌─1bit─┬────41 bits────┬───10 bits───┬──12 bits──┐
│ 保留 │ 时间戳(ms级) │ 机器ID+DC │ 序列号 │
└───────┴───────────────┴────────────┴──────────┘
符号位 69 年范围 1024 节点 4096/ms
订单号增强设计(交易所场景)
订单号 = [业务码 2位] + [时间戳 13位] + [分片路由 2位] + [机器ID 3位] + [序列号 4位] + [校验位 1位]
示例:SP20250819153000012030015
- 业务码:SP(现货) / FU(合约) / WI(提现)
- 分片路由:user_id % 100 → 决定路由到哪个分库
时钟回拨应对
方案1(推荐):等待。回拨 < 10ms 时,自旋等待追上上次时间。
方案2:借用未来。回拨较大时,沿用"上次最大时间戳 + 1",记录告警。
方案3(终极):启动时 NTP 同步,运行时拒绝 > 5s 的回拨,直接报错。
记忆锚
"雪花 + 业务前缀 + 分片路由 + 3 种时钟回拨"。面试时说:我用 Snowflake 增强版,订单号自带分库路由信息,解决了时钟回拨 N 种情况。
Q6:如何设计防止重复下单的机制?
TL;DR
防重 = 客户端幂等 Token + 服务端去重表 + DB 唯一索引,三层防线。核心:在提交订单前先申请一个 token,提交时带 token,服务端判断 token 是否已使用。
完整链路
三层防重对比
| 层级 | 方案 | 作用 | 局限性 |
|---|---|---|---|
| 客户端 | 按钮置灰 + Token | 防止用户误点 | 可绕过 |
| 服务端 | Redis Token + 去重表 | 防止重复提交 | 需要原子操作 |
| DB | 唯一索引(order_id UNIQUE) | 最终兜底 | 并发下可能报错 |
❌ 误区
| ❌ | ✅ |
|---|---|
| "前端按钮置灰就够了" | 用户可刷新、后退、或直接 curl 调用,必须服务端防重 |
| "Redis SETNX 就够了" | Token 过期后可能重复,需 DB 唯一索引终极兜底 |
| "事务就能防重" | 事务保证原子性但不保证幂等,两个并发事务都会成功 |
记忆锚
"Token + DELETE + 唯一索引":核心是 Redis DEL(原子判断),失败则 DB 唯一索引兜底。
板块二:行情/交易系统设计(Q7-Q18)
Q7:低延迟行情推送服务的整体架构
TL;DR
行情推送 = 交易所网关接收 tick → 内存撮合/聚合 → WebSocket 广播。低延迟核心:全内存操作 + 零拷贝 + 单线程 EventLoop。P99 < 1ms 是硬指标。
类比
🏟️ 体育场实时比分屏:比分变化(tick)→ 记分员更新(聚合)→ 大屏幕即时显示(推送)。没有人去查数据库——全部在"现场"完成。
核心架构
关键设计决策
| 决策点 | 方案 | 为什么 |
|---|---|---|
| 订单簿存储 | 内存有序 Map(TreeMap/SkipList) | O(logN) 插入/删除,无需 DB 查询 |
| K 线聚合 | 内存滑动窗口 + 定时触发 | 1min K 线 = 60s 窗口内 OHLC |
| 推送方式 | WebSocket + 订阅模式 | 长连接,用户只收订阅的币对 |
| 持久化 | 异步 Kafka 落库 | 不阻塞推送主链路 |
| 语言选择 | Go / C++ / Rust | GC 语言需调优(见 Q18) |
延迟预算(P99 < 1ms 怎么做到的)
网络接收: 0.05ms
订单簿更新: 0.10ms ← TreeMap O(logN)
K线聚合: 0.05ms
推送编码: 0.10ms
网络发送: 0.10ms
─────────────────────
总计: ~0.50ms ← P99 < 1ms 可行
记忆锚
"全内存 + TreeMap + WebSocket 广播":行情推送就是"拿tick→更新内存→广播",持久化异步走 Kafka。
Q8:每秒百万级 tick 数据 + 实时聚合 K 线,存储和计算方案
TL;DR
百万 tick/s = 每微秒 1 个 tick。计算:内存滑动窗口 + 增量更新(新 tick 只更新当前 K 线)。存储:热数据在内存,温数据在 Redis,冷数据在时序数据库 + 降采样。
类比
📈 股票软件上的 K 线图:你看到的每根蜡烛图背后是 1 分钟内几百个 tick 的聚合。聚合在内存中完成(hot path),历史 K 线从时序 DB 查(cold path)。
架构设计
聚合算法(增量更新)
// 每来一个 tick,只更新当前 K 线的 4 个值
type KLine struct {
Open float64
High float64
Low float64
Close float64 // 持续更新
Volume float64 // 累加
}
func (k *KLine) Update(tick Tick) {
if k.Volume == 0 { k.Open = tick.Price }
if tick.Price > k.High { k.High = tick.Price }
if tick.Price < k.Low { k.Low = tick.Price }
k.Close = tick.Price
k.Volume += tick.Volume
}
复杂度:每个 tick O(1) 更新,百万 tick/s 需要约 10 个核心(每个核心处理 10 万 tick/s)。
容量估算
100 万 tick/s × 每个 tick 80 bytes = 80 MB/s 写入
K 线数据:100 个币对 × 3 种窗口 × 200 bytes = 60 KB 内存
Kafka 分区:100万 / (单分区 10万吞吐) = 10 分区 → 保守设 32 分区
记忆锚
"O(1) 增量聚合 + 时间窗口吃新吐旧 + 异步落时序 DB"
Q9:高效 WebSocket 服务广播行情数据
TL;DR
核心是单机 10 万连接的分层设计:连接层(Netty/Go netpoller)→ 订阅路由层(topic→connections 映射)→ 推送层(批量 flush + 零拷贝)。
类比
📻 广播电台:发射塔(WebSocket Server)持续广播,用户调频到对应频道(subscribe BTC/USDT),只收到自己频道的信号。
架构
关键设计点
| 设计点 | 方案 | 细节 |
|---|---|---|
| 连接模型 | 异步非阻塞 I/O(Netty/Go netpoller) | 每连接不占线程,10 万连接仅需少量 EventLoop 线程 |
| 订阅管理 | topic → connSet 内存映射 | O(1) 查找需要推送的连接 |
| 推送优化 | 批量 flush + writev 系统调用 | 减少系统调用次数,一次推送多个连接 |
| 心跳 | WS Ping/Pong 30s 间隔 | 检测死连接,主动断开 |
| 背压处理 | 发送缓冲区满 → 丢帧 or 断开 | 宁可丢帧不阻塞整个服务 |
| 水平扩展 | 按币对分片(BTC→集群A, ETH→集群B) | 不同集群互不影响 |
单机能支持多少连接?
Linux 默认:单进程 1024 fd → ulimit -n 1000000
内核参数调优:
- net.ipv4.tcp_mem(TCP 内存)
- net.ipv4.ip_local_port_range(端口范围)
- fs.file-max(系统级 fd 上限)
理论:4GB 内存 → 10 万连接 × 4KB buffer = 400MB,完全可行
实际:单机 50 万连接需要精细化内存管理
记忆锚
"异步 I/O + 订阅映射 + 批量 writev":WebSocket 服务三个核心优化点。
Q10:微服务架构下多行情服务实例状态同步
TL;DR
行情实例状态同步 = Redis Pub/Sub(实时通知)+ 版本号/时间戳(冲突解决)。但更好的方案是让每个实例独立消费 Kafka 分区,天然无状态。
方案对比
| 方案 | 机制 | 优点 | 缺点 |
|---|---|---|---|
| Redis Pub/Sub | 实例A更新 → 发布 → 实例B订阅更新 | 实时性好 | 消息不持久,重启丢失 |
| Kafka 分区消费 | 每个实例消费独立分区 | 天然无状态,无需同步 | 分区数 = 实例数 |
| Gossip 协议 | 实例间定期交换状态 | 去中心化,高可用 | 收敛慢,不适合实时 |
| 集中式存储(Redis) | 所有实例读写同一个 Redis | 强一致,最简单 | Redis 是单点(可用集群) |
推荐方案:集中式 Redis + 本地缓存
原则:行情数据适合集中式存储 + 本地缓存,因为延迟敏感,一致性要求不如资金系统严格。
记忆锚
"Redis 做主存储,本地 Caffeine 做热缓存,Pub/Sub 做变更通知"
Q11:可水平扩展的行情数据历史存储与查询系统
TL;DR
历史行情 = 时序数据库(ClickHouse/InfluxDB/TDengine) 做主力存储 + 对象存储(S3) 做归档 + Redis 做最近热数据缓存。查询路由:最近 1 天查 Redis → 1 年查 ClickHouse → 全量查 S3。
类比
🗄️ 银行流水:最近 3 个月(Redis/热存储)随时查 → 去年流水(ClickHouse/温存储)稍慢但能查 → 10 年前流水(S3 归档/冷存储)需调档。
架构
降采样策略
原始数据:1min K线,保留 30 天
聚合数据:
- 5min K线,保留 90 天
- 1h K线,保留 1 年
- 1d K线,保留 10 年
存储估算:100 币对 × 1年 × 1min K线 × 200B = ~10GB(可控)
记忆锚
"时序 DB 主力 + 对象存储归档 + 降采样金字塔 + Redis 热缓存"
Q12:行情数据压缩减少网络传输和存储成本
TL;DR
压缩 = 协议层 Protobuf(比 JSON 小 5-10 倍)+ 数据面 Delta 编码(只传变化量)+ 应用层快照+增量(首次全量,后续只推差异)。
压缩层次
第 1 层:序列化压缩(Protobuf vs JSON)
JSON: {"symbol":"BTCUSDT","price":67890.12,"volume":1.5}
Proto: 08 06 42 54 43... (约 15 bytes vs JSON 60 bytes → 4x)
第 2 层:Delta 编码
不传绝对值,传"价格 +0.5, 成交量 +0.1" → tick 数据常见 10x 压缩
第 3 层:快照 + 增量
首次连接推送全量订单簿快照(1000 条)
后续只推送变化的档位(3-5 条)→ 20x 压缩
大型加密货币交易所 WebSocket 实践
大型加密货币交易所行情流实际上就是:
1. 先发一个全量快照(depth snapshot)
2. 每个 update 只发变化的档位
3. update 里的 lastUpdateId 用于检测丢包
4. 丢包后重新请求全量快照
记忆锚
"Protobuf + Delta + 快照增量",三层压缩逐级放大。
Q13:低延迟 vs 高吞吐量的平衡
TL;DR
低延迟和高吞吐在微观上矛盾(批量处理提高吞吐但增加延迟),但可以通过流水线化 + 分区并行在宏观上兼顾。行情场景:延迟优先(P99 < 1ms),吞吐通过水平扩展补足。
类比
🏎️ F1 赛车 vs 货运卡车:F1(低延迟)每趟载 1 人但极快;卡车(高吞吐)每趟载 50 人但慢。你要做的是建更多赛道(分区并行),让 F1 也能运很多人。
决策框架
行情场景具体取舍
| 取舍 | 倾向 | 原因 |
|---|---|---|
| 单条推送 vs 批量推送 | 单条 | 批量等 1ms 就增加 1ms 延迟 |
| 压缩 vs 不压缩 | 不压缩/轻量 | 压缩省带宽但耗 CPU+延迟 |
| 同步 vs 异步持久化 | 异步 | 落库不阻塞推送主链路 |
| 单线程 vs 多线程 | 单线程 EventLoop | 避免锁竞争和上下文切换 |
记忆锚
"行情延迟优先,通过分区扩展吞吐"
Q14:跨数据中心行情数据同步
TL;DR
跨 DC 同步 = 专线(网络层)+ 主从复制(数据层)+ 冲突解决(应用层 Last-Write-Wins)。核心挑战是光速限制——纽约到东京光缆单向延迟 ~75ms,无法做到实时一致。
方案对比
| 方案 | 延迟 | 一致性 | 适用场景 |
|---|---|---|---|
| 专线 + 主从复制 | <10ms(同区域) | 强一致 | 同区域多 AZ |
| 异步消息同步(Kafka MirrorMaker) | 秒级 | 最终一致 | 跨区域(亚→美) |
| Gossip 协议 + 版本向量 | 秒~分钟 | 最终一致 | 多写场景 |
| 全局消息队列 + 本地消费 | <100ms(区域) | 最终一致 | 混合方案 |
跨区域实时 K 线的"不可能三角"
实时性
/\
/ \
/ \
/ 选择 \
/ 两个 \
/__________\
一致性 分区容忍性
现实:跨区域数据同步只能选"最终一致性"。大型加密货币交易所 的做法是为每个区域部署独立行情集群,区域间异步同步,用户在哪个区域就用哪里的数据。
记忆锚
"光速限制 75ms,跨洋只能最终一致"
Q15:设计简化版数字货币交易所核心交易引擎
TL;DR
撮合引擎 = 订单簿(Order Book) 维护买卖盘口 + 匹配逻辑(价格优先→时间优先)+ 成交生成。核心数据结构:买盘最大堆 + 卖盘最小堆,或使用红黑树(TreeMap)。
类比
🏠 房产中介撮合:买家出价按从高到低排(买盘),卖家要价按从低到高排(卖盘)。最高买价 ≥ 最低卖价 → 成交!否则挂单等待。
模块划分
核心数据结构
// 订单簿:买盘用最大堆(价格最高在前),卖盘用最小堆(价格最低在前)
class OrderBook {
// key=price, value=该价格的订单队列(FIFO)
TreeMap<Double, Queue<Order>> bids; // 买盘,降序
TreeMap<Double, Queue<Order>> asks; // 卖盘,升序
}
// 匹配逻辑
void match() {
while (!bids.isEmpty() && !asks.isEmpty()) {
double bestBid = bids.lastKey(); // 最高买价
double bestAsk = asks.firstKey(); // 最低卖价
if (bestBid >= bestAsk) {
// 成交!取最早订单(时间优先)
Order buy = bids.get(bestBid).poll();
Order sell = asks.get(bestAsk).poll();
executeTrade(buy, sell);
} else {
break; // 无匹配,等待新订单
}
}
}关键设计决策
| 决策 | 方案 | 原因 |
|---|---|---|
| 数据结构 | TreeMap(红黑树) | O(logN) 插入/查找,天然有序 |
| 排序规则 | 价格优先→时间优先 | 交易所标准规则 |
| 并发 | 单线程 EventLoop(Disruptor 模式) | 避免锁竞争,撮合引擎是 CPU 密集型 |
| 持久化 | 先成交→落 Kafka→异步写 DB | 不能因为 DB 慢阻塞撮合 |
| 灾备 | 主从 + 同步写 WAL | 主节点故障时从节点恢复 |
❌ 误区
| ❌ | ✅ |
|---|---|
| "用数据库做撮合" | 数据库事务延迟 ms 级,撮合需要 μs 级 |
| "多线程并行撮合" | 锁竞争严重,反而不如单线程 + 无锁设计 |
| "撮合和推送放在一个线程" | 推送可能阻塞撮合,应分离 |
记忆锚
"TreeMap + 价格优先 + 时间优先 + 单线程 EventLoop"
Q16:高并发下单如何解决超卖?
TL;DR
超卖防护从快到慢:Redis Lua 原子预减(最快)→ DB 乐观锁(版本号/条件更新)→ DB 悲观锁(SELECT FOR UPDATE,最慢但最安全)。交易所场景推荐 Redis Lua + DB 唯一索引双保险。
类比
🎫 演唱会门票:你在手机 App 看到"剩余 2 张"(Redis 缓存),点购买时真正的扣减发生在服务器(Lua 原子操作)。两个人都看到"剩余 2 张"但只有 1 个人能买到——Lua 原子保证了只有一个 DECR 成功。
方案对比
| 方案 | 并发能力 | 安全级别 | 适用场景 |
|---|---|---|---|
| Redis Lua 原子 DECR | 10 万 QPS | ⭐⭐⭐ | 秒杀/高频场景 |
| DB 乐观锁(version 字段) | 1 万 QPS | ⭐⭐⭐⭐ | 一般并发 |
| DB 悲观锁(SELECT FOR UPDATE) | 1000 QPS | ⭐⭐⭐⭐⭐ | 资金扣减 |
| 分段库存(Redis 多 Key) | 100 万 QPS | ⭐⭐⭐ | 极高并发 |
三层防护
层 1(Redis Lua):return redis.call('DECR', KEYS[1]) >= 0
层 2(DB 乐观锁):UPDATE stock SET qty = qty - 1 WHERE id = ? AND qty >= 1
层 3(DB 唯一索引):UNIQUE(order_id, user_id) 防止重复扣
记忆锚
"Lua 原子 DECR + 乐观锁 version + 唯一索引兜底"
Q17:支持多种订单类型的扩展撮合引擎
TL;DR
扩展性 = 策略模式(每种订单类型一个 MatchStrategy)+ 订单簿不变(统一数据结构)+ 插件化注册(新增订单类型无需改撮合核心)。
架构
策略模式设计
interface MatchStrategy {
MatchResult execute(Order order, OrderBook book);
}
class LimitOrderStrategy implements MatchStrategy {
// 限价单:只按指定价格或更优价格成交
// 未成交部分挂单
}
class IcebergOrderStrategy implements MatchStrategy {
// 冰山订单:只暴露 displayQty,成交后再显示下一批
}冰山订单的核心逻辑
冰山订单 = 大单分小块,每次只显示 displayQty(如 100 BTC 的冰山,每次显示 10 BTC)
- 每次显示的 10 BTC 成交后,自动从隐藏量中补充下一个 10 BTC
- 防止大单砸盘,隐藏真实意图
记忆锚
"策略模式 + 统一订单簿 + 插件注册"
Q18:撮合引擎低延迟场景下如何减少 GC 停顿?
TL;DR
GC 优化三板斧:对象池复用(减少分配)→ 堆外内存(绕过 GC)→ ZGC/Shenandoah(亚毫秒停顿)。再加一招:定时重启(每天凌晨低峰滚动重启)。
Java 方案
| 方案 | 效果 | 实现 |
|---|---|---|
| 对象池(Object Pool) | 减少 80% 对象分配 | 订单对象池、交易对象池 |
| 堆外内存(DirectByteBuffer) | 订单簿存堆外,0 GC | Chronicle Queue / MapDB |
| ZGC | P99 停顿 < 1ms | -XX:+UseZGC -Xms16G -Xmx16G |
| 定时重启 | 每天重启,重置堆 | K8s CronJob 滚动重启 |
Go 方案
| 方案 | 效果 | 实现 |
|---|---|---|
| sync.Pool | 复用对象,减少分配 | 订单对象池 |
| 逃逸分析优化 | 栈上分配,不进堆 | 传值而非传指针 |
| GOGC=off + 手动触发 | 定时 GC,避开交易高峰 | 非高峰期手动 runtime.GC() |
| GOMEMLIMIT | 软限制堆大小 | Go 1.19+ |
对象池模式(Java)
// 关键:避免撮合过程中 new 对象
class OrderPool {
private Queue<Order> pool = new ConcurrentLinkedQueue<>();
Order acquire() {
Order o = pool.poll();
return o != null ? o.reset() : new Order();
}
void release(Order o) {
pool.offer(o);
}
}记忆锚
"池化复用 + 堆外绕行 + ZGC + 定时重启"
板块三:交易所/风控特化系统设计(Q19-Q28)
Q19:设计实时交易风控引擎
TL;DR
风控引擎 = 事件接入 → 特征补全(enrichment) → 规则判定 → 模型打分 → 决策输出。核心 SLA:P99 < 50ms、99.99% 可用、误杀率 < 0.1%。
注:这道题你有完整文档 s1-design-realtime-risk-engine.md,此处给出面试口述版本。
类比
🛂 机场智能安检:接入层 = 入口闸机(鉴权+限流)→ 特征层 = X光机+金属探测(实时扫描 + 调取旅客历史)→ 决策层 = 安检员+AI判图(规则+模型综合判定)→ 执行层 = 放行/拦截。
四层架构(面试口述版)
接入层(<5ms)
├── 鉴权 + 限流 + 协议适配(HTTP/gRPC)
└── 同步请求 → 风控引擎 / 异步事件 → Kafka
特征层(<15ms)
├── 本地缓存:用户画像(设备指纹/IP/历史行为)
├── Redis:实时特征(1min交易次数/金额/币种)
└── 异步补全:链上数据/KYC/关联图谱
决策层(<20ms)
├── 规则引擎:优先级短路(黑名单先判 → 白名单跳过 → 普通规则)
├── ML模型:风险评分(LightGBM/XGBoost → ONNX Runtime)
└── 融合:规则 + 模型加权 → PASS/REVIEW/BLOCK
执行层(<10ms)
├── 同步:返回决策结果给调用方
└── 异步:写审计日志 → Kafka → Hive 离线分析
分层降级策略
规则引擎挂了 → ML 模型独立决策(降级)
ML 模型挂了 → 纯规则兜底(降级)
Redis 挂了 → 本地缓存 + 默认 PASS 保守策略 ← 关键!
风控全挂 → 熔断器打开 → 跳过风控直接放行(fail-open)
关键数字(面试时说出来)
QPS: 100K+(单集群)
P50: < 20ms
P99: < 50ms
可用性: 99.99%
误杀率: < 0.1%
记忆锚
"接入→特征→决策→执行,四层 < 50ms,挂了就降级" — 这是面试时 30 秒讲完的口述版本。
Q20:设计规则引擎服务
TL;DR
规则引擎 = DSL 定义 + 编译缓存 + 优先级短路执行 + 热更新。核心取舍:ReTe 网络(内存换速度)vs 线性扫描(简单但慢),风控场景推荐轻量自研方案。
注:你有完整文档 s2-design-rule-engine-service.md。
规则 DSL 示例
{
"ruleId": "RULE_WITHDRAW_LARGE_NEW_DEVICE",
"name": "大额提现+新设备拦截",
"salience": 100,
"conditions": [
{"field": "amount", "op": ">", "value": 100000},
{"field": "deviceAge", "op": "<", "value": "7d"},
{"field": "kycLevel", "op": "!=", "value": "VIP5"}
],
"action": "BLOCK",
"reason": "大额提现 + 新设备 + 非VIP5用户"
}热更新机制
关键:热更新必须是原子切换——新规则编译完成后,一个指针/引用切换就生效,不能出现"一半新一半旧"的状态。
记忆锚
"DSL + 优先级短路 + 原子热切换 + 降级兜底"
Q21:设计高性能准实时全球用户资产持仓快照服务
TL;DR
持仓快照 = 账户服务变更事件 → Kafka → 实时计算 → Redis(热)+ DB(持久)。核心挑战:全球部署下的延迟 + 一致性 + 海量用户。
类比
📸 Google Photos 的"实时相册":你每拍一张照片(账户变更),后台自动更新你的"相册封面图"(持仓快照)。你打开相册 App 时(查询快照),看到的永远是最新的封面,不需要每次重新扫描所有照片。
架构
核心设计
实时路径(毫秒级):
交易成交 → Kafka 事件 → 快照计算(增量更新:只更新变化的币种)
→ Redis HSET user:{id}:positions {symbol} {qty}
查询路径:
GET /api/positions → Redis HGETALL → 毫秒级返回
对账路径(每小时):
Redis 快照 vs DB 账户表 → 差异 > 阈值 → 告警 + 修正
关键 trade-off
| 选择 | 原因 |
|---|---|
| 增量更新而非全量重算 | 用户可能持有 50 个币种,交易只涉及 1 个 |
| Redis 做主存储 | 读多写少,毫秒级查询 |
| 按 user_id Kafka 分区 | 同一用户的事件有序处理,避免并发冲突 |
| 每小时对账 | 最终一致性兜底,发现差异自动修复 |
记忆锚
"增量更新 + Redis 缓存 + 按 user_id 分区 + 每小时对账"
Q22:设计高并发限流/频控服务
TL;DR
限流 = 滑动窗口计数(Redis Lua)+ 令牌桶/漏桶(本地限流)+ 多级限流(用户级 → IP 级 → 全局限流)。分布式限流核心挑战:精度 vs 性能的平衡。
类比
🚗 高速收费站:ETC 通道(令牌桶——固定速率放行)vs 人工通道(漏桶——排队等待)。ETC 允许短时间超速(攒的令牌一次性放),但不允许长时间超量。
滑动窗口实现(Redis Lua)
-- 滑动窗口限流:每个用户每秒最多 N 个请求
local key = KEYS[1] -- "ratelimit:user:123"
local now = tonumber(ARGV[1]) -- 当前时间戳 ms
local window = tonumber(ARGV[2]) -- 窗口大小 ms (1000ms)
local limit = tonumber(ARGV[3]) -- 限制次数
-- 移除窗口外的记录
redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
-- 统计当前窗口内请求数
local count = redis.call('ZCARD', key)
if count < limit then
redis.call('ZADD', key, now, now .. '-' .. math.random())
redis.call('PEXPIRE', key, window)
return 1 -- 允许
else
return 0 -- 拒绝
end多级限流架构
第 1 级:Nginx 令牌桶(全局限流,10 万 QPS)
第 2 级:Gateway Sentinel(IP 级限流,1000 QPS/IP)
第 3 级:服务层 Redis Lua(用户级限流,100 QPS/用户)
第 4 级:业务层信号量(并发度限制,50 并发)
分布式限流精度问题
问题:10 个服务实例,每个限制 100 QPS → 总限制 1000 QPS(而非 100)
解决:Redis 集中计数(精度高但多一次网络请求)
折中:本地预取令牌(每 100ms 从 Redis 预取一批,本地分发)
记忆锚
"ZSET 滑动窗口 + Lua 原子 + 四级限流 + 预取令牌"
Q23:风控系统重构的架构设计与技术选型
TL;DR
重构不是重写 = 渐进式演进 + 绞杀者模式(strangler fig)+ 灰度切流。第一阶段不改核心逻辑,只做接口标准化;第二阶段逐步替换老系统模块;第三阶段全量切换。
类比
🏗️ 上海外滩隧道改造:不能封路施工(业务不能停)。方案:在旁边挖一条新隧道(新系统并行跑),逐步切换车流(灰度切流),老隧道最后废弃。
三步走策略
技术选型矩阵
| 组件 | 老系统 | 新选型 | 原因 |
|---|---|---|---|
| 规则引擎 | Drools | 自研轻量 DSL | 热更新更快,依赖更少 |
| 特征存储 | MySQL | Redis + 本地缓存 | 降低延迟 10x |
| 消息队列 | RabbitMQ | Kafka | 吞吐量提升,分区有序 |
| 模型服务 | Python Flask | Triton/ONNX | 推理加速,多模型管理 |
| 实时计算 | 无 | Flink CEP | 复杂事件检测 |
风险控制
1. 双写双读:新老系统并行处理同一份流量,对比结果 2 周
2. 灰度切流:1% → 10% → 50% → 100%,每步观察 3 天
3. 一键回滚:配置中心开关 → 瞬间切回老系统
4. 数据校验:差异率 > 0.01% 自动告警
记忆锚
"绞杀者模式 + 三步走 + 双写双读验证 + 一键回滚"
Q24:风控场景 API 高并发优化
TL;DR
风控 API 优化 = 本地缓存(减少 90% Redis 调用)+ 规则预编译(AST 树提前构建)+ 特征异步补全(先返回已知特征的结果,后台补充剩余特征)+ 连接池复用。
优化层次
| 优化点 | 手段 | 收益 |
|---|---|---|
| 减少网络调用 | 特征本地缓存(Caffeine 1min TTL) | 延迟 -70% |
| 减少计算开销 | 规则预编译为 AST,运行时直接匹配 | CPU -50% |
| 减少同步等待 | 黑名单/白名单同步,用户行为异步 | 延迟 -30% |
| 连接复用 | gRPC 连接池 / HTTP Keep-Alive | QPS +200% |
| 序列化优化 | Protobuf 替代 JSON | 带宽 -60% |
记忆锚
"本地缓存 + 预编译 + 异步补全 + Protobuf"
Q25:风控系统超时/报错如何避免影响交易?
TL;DR
Fail-open 策略:风控挂了 → 放行交易(而非阻断)。核心机制:熔断器(连续超时 N 次 → 跳过风控直接放行)→ 超时降级(超时 50ms → 返回默认 PASS) → 事后审计补偿(放行的交易异步重新检查)。
类比
🏥 急诊室分诊:正常流程是挂号→问诊→检查→开药。如果挂号系统挂了,急诊室不会让病人等死——直接让医生先看(fail-open),系统恢复后再补录挂号信息(事后补偿)。
决策树
熔断器配置
连续失败 5 次 → OPEN(跳过风控直接放行)
30s 后 → HALF_OPEN(尝试 1 个请求)
成功 → CLOSED(恢复正常)
失败 → OPEN(继续跳过)
事后补偿
放行交易时记录 audit log → Kafka → 风控离线重新检查
发现风险 → 人工介入(冻结账户/撤销交易)
对正常用户无感知
记忆锚
"Fail-open + 熔断器 + 50ms 超时 + 事后补偿审计"
Q26:API 网关限流/熔断/降级策略
TL;DR
网关三件套:限流(令牌桶/滑动窗口,保护下游) → 熔断(连续失败 OPEN,快速失败) → 降级(返回兜底数据/默认值)。Sentinel / Spring Cloud Gateway 都可实现。
三件套对比
| 机制 | 目标 | 触发条件 | 动作 |
|---|---|---|---|
| 限流 | 防过载 | QPS 超阈值 | 拒绝多余请求,返回 429 |
| 熔断 | 防雪崩 | 错误率 > 50% | 快速失败,不调下游 |
| 降级 | 保有损服务 | 下游不可用 | 返回兜底数据/缓存 |
网关层实现(Spring Cloud Gateway + Sentinel)
# 限流规则
- uri: /api/trade/**
rateLimit:
burst: 1000 # 突发容量
replenishRate: 500 # 每秒补充 500 令牌
# 熔断规则
- uri: /api/risk/**
circuitBreaker:
failureRateThreshold: 50% # 50% 失败 → 熔断
waitDurationInOpenState: 30s # 30s 后半开记忆锚
"限流保护下游,熔断快速失败,降级兜底服务"
Q27:私有化托管迁移到云的规划
TL;DR
云迁移 = 评估(依赖/数据/网络)→ 选型(AWS/GCP/阿里云)→ 迁移(先非核心→再核心,灰度切流)→ 优化(成本/性能)。核心原则:先 lift-and-shift,再 optimize。
注:这道题将在 B9 详细展开,此处给出面试口述框架。
四阶段
阶段 1(评估,2 周):盘点所有服务、依赖、数据量、合规要求
阶段 2(选型,1 周):对比云厂商(计算/存储/网络/托管服务/合规)
阶段 3(迁移,1-3 月):先迁移非核心服务 → 验证 → 切流量
阶段 4(优化,持续):弹性伸缩、预留实例、成本分析
迁移策略
Lift & Shift(原样搬迁):最快,但不利用云特性
Refactor(云原生改造):把 MySQL 换 RDS,自建 Kafka 换 MSK
Replace(SaaS 替换):自建监控换 CloudWatch
记忆锚
"评估→选型→灰度迁移→优化",四步走。面试重点说"先 lift-and-shift,再 optimize"证明你务实。
Q28:设计实时排行榜(如直播间打赏榜)
TL;DR
排行榜 = Redis Sorted Set(ZADD 更新分数 + ZREVRANGE 查询 Top N)+ 分段榜单(全量榜 + 每小时榜 + 每天榜)。热点用户用本地缓存 Top 100。
类比
🏆 F1 年度积分榜:比赛结束(打赏事件)→ 加积分(ZADD)→ 实时更新排名(ZREVRANGE)。观众随时看到最新排名,不需要重新计算。
架构
// 更新分数
redis.zadd("rank:live:room:123", newScore, userId);
// 查询 Top 100
Set<String> top100 = redis.zrevrange("rank:live:room:123", 0, 99);
// 查询某人排名
Long rank = redis.("rank:live:room:123", userId);关键设计
问题:亿级用户,ZSET 内存太大?
解决:
1. 只存前 1000 名(小于 1000 名的异步写入)
2. 分段榜单:全量榜(前1000) + 每日榜(当天)
3. 本地缓存 Top 100,1s 刷新一次
记忆锚
"Redis ZADD + ZREVRANGE + 分段榜单 + Top100 本地缓存"
板块四:架构/容量规划(Q29-Q35)
Q29:面向流量百倍增长的瓶颈评估和平滑扩容
TL;DR
评估瓶颈 = 压测找天花板(单机极限 QPS)→ 识别瓶颈层(CPU/内存/IO/DB连接)→ 扩容方案(水平扩展优先于垂直扩展)。平滑扩容 = 提前扩容(在 60% 水位线开始加机器)+ 预热(新机器先接 10% 流量)。
瓶颈评估优先级
1. DB 连接池(最脆弱,先评估)
2. Redis 单 Key 热点(QPS 上限 ~10 万)
3. Kafka 分区数(消费者 ≤ 分区数)
4. 应用层 CPU(无状态,最容易扩展)
5. 带宽(跨 DC 专线瓶颈)
扩容节奏
水位 60% → 开始采购机器(预留 2 周到货)
水位 70% → 提前扩容,新节点预热
水位 85% → 紧急扩容,同时启动限流
水位 90% → 限流 + 降级非核心功能
记忆锚
"压测定天花板 → 60% 预警 → 水平扩展 → 预热切流"
Q30:容量规划——用户半年增长 10 倍
TL;DR
容量规划 = QPS 估算(用户量 × 人均请求 × 峰值系数)→ 单机容量(压测得出)→ 机器数 = QPS ÷ 单机容量 × 冗余系数 1.5。同时评估:DB 数据量增长、Kafka 吞吐增长、带宽增长。
计算公式
日活用户: 100万 → 1000万 (10x)
峰值 QPS: 日活 × 人均请求数(5) ÷ 86400 × 峰值系数(3)
= 1000万 × 5 ÷ 86400 × 3 ≈ 1736 QPS
应用机器: 1736 ÷ 单机容量(500 QPS) × 1.5(冗余) ≈ 6 台
DB 存储: 当前 100GB × 10(用户增长) × 1.5(冗余) = 1.5TB → 考虑分库分表
Redis: 当前 20GB × 10 × 1.5 = 300GB → Cluster 模式
带宽: 当前 1Gbps × 10 = 10Gbps
记忆锚
"QPS = 用户 × 人均请求 × 峰值系数,机器 = QPS ÷ 单机 × 1.5"
Q31:行情服务容量规划(带宽/CPU/内存)
TL;DR
行情服务资源估算:
| 资源 | 估算公式 | 示例 |
|---|---|---|
| 带宽 | 订阅用户 × 每秒推送次数 × 每条大小 | 10万用户 × 10次/s × 500B = 500MB/s = 4Gbps |
| CPU | tick 处理延迟 × tick 速率 / 核心数 | 100万tick/s × 1μs = 1核(理论)→ 实际 8-16 核 |
| 内存 | 订单簿 × 币对 + 连接 buffer + 进程开销 | 100币对 × 1MB + 10万连接 × 4KB = ~500MB |
记忆锚
"带宽 4Gbps / CPU 16核 / 内存 500MB" — 面试时能说出量级就是 Senior 的证明。
Q32:理想的高频金融交易后端系统应具备哪些核心特质?
TL;DR
六个特质:低延迟(μs 级)、高可用(99.99%+)、确定性(状态机可回放)、可扩展(水平扩展)、可观测(全链路追踪)、安全(零信任架构)。
六个特质详解
| 特质 | 指标 | 实现手段 |
|---|---|---|
| 低延迟 | P99 < 100μs | 全内存、无锁、Disruptor 模式 |
| 高可用 | 99.99%+ | 主从热备、自动故障转移 |
| 确定性 | 状态可回放 | Event Sourcing + WAL 日志 |
| 可扩展 | 水平分片 | 按 symbol/user_id 分片 |
| 可观测 | 全链路 ms 级 | Metrics + Tracing + Logging |
| 安全 | 零信任 | mTLS + API Key + 审计 |
记忆锚
"快(μs)、稳(4个9)、准(确定回放)、大(水平扩)、透(可观测)、安(零信任)"
Q33:量化交易对行情系统的新挑战?架构如何演进?
TL;DR
量化交易的冲击:延迟从 ms 卷到 μs(纳秒级竞争)+ 数据频率从秒级到 tick 级 + 策略多样性(做市/套利/趋势)。架构演进:FPGA 硬件加速 → 数据中心托管(colocation) → 专线直连。
延迟竞赛
传统:用户 App → 互联网 → 交易所(~50ms)
量化:服务器 → 专线 → 交易所托管机房(~10μs)
极限:FPGA → 直连匹配引擎(< 1μs)
架构演进方向
当前:软件撮合(TreeMap/C++)
近期:硬件加速(FPGA 解析 FIX 协议 + 预匹配)
长期:分布式 + 就近撮合(不同区域独立撮合,降低光速延迟)
记忆锚
"ms→μs→ns,软件→FPGA→colocation"
Q34:如何利用 ES 实现海量行情日志快速检索与聚合?
TL;DR
ES 用于行情日志检索:时间分片索引(按天切索引)→ 冷热分离(热数据 SSD,冷数据 HDD)→ 索引模板(自动创建下一周期索引)→ 聚合查询(K 线聚合用 ES Date Histogram)。
架构
优化要点
1. 按天建索引:market-data-2025-08-19,自动过期删除
2. 冷热分离:近 7 天 SSD,超过 7 天迁移到 HDD
3. 禁用 _source 或压缩:节省 50% 存储
4. refresh_interval: 30s(而非默认 1s),减少写入开销
5. 聚合预计算:每小时预聚合 K 线存入单独索引
记忆锚
"按天索引 + 冷热分离 + 预聚合 + Kibana 可视化"
Q35:对接外部行情源——健壮客户端设计
TL;DR
外部行情源客户端 = 连接池(多连接负载均衡)→ 心跳检测(30s 无数据则重连)→ 熔断降级(连续失败切备用源)→ 数据校验(价格范围/时间戳连续性检查)→ 快照恢复(断连后从上次 seq 恢复)。
架构
容错机制
1. 主备切换:主源连续 3 次超时 → 自动切备源
2. 数据校验:价格偏离 > 5% 或时间戳跳跃 → 丢弃 + 告警
3. 快照恢复:断连后,重新订阅 + 从 snapshot 恢复 order book
4. 指数退避重连:1s → 2s → 4s → 最多 60s
5. 熔断器:5 次连续失败 → OPEN,30s 后 HALF_OPEN
记忆锚
"主备切换 + 数据校验 + 快照恢复 + 指数退避重连"
总结:系统设计面试的 5 个万能金句
1. "我先对齐一下范围:用户量、QPS、延迟要求、可用性目标。"
→ 展现 Senior 的职业素养
2. "我采用分层/分阶段的设计,每一层都有独立的降级策略。"
→ 展现架构思维
3. "这里有一个 trade-off:一致性 vs 延迟 vs 可用性。我的选择是…因为…"
→ 展现决策能力
4. "这个方案在生产环境还有一个坑:…,我的应对是…"
→ 展现经验深度
5. "如果业务规模再扩大 10 倍,我会从哪些方面进一步优化:…"
→ 展现前瞻性
B1 补充:系统设计追问(Q36-Q40)
来自
questions.md:签到系统、负载均衡、BASE/AP、游民系统实践。
Q36:签到系统怎么设计?
TL;DR
签到 = BitMap(按日期+用户维度,签到=1,未签=0)。查询:BITFIELD 今天+本月累计。连续签到天数:BITFIELD 后判断从今天往前连续几个 1。
为什么用 BitMap?
1 个用户 1 年签到数据 = 365 bit = 46 字节
1 亿用户 × 46 字节 = 4.6GB → Redis Cluster 轻松存
如果用 MySQL:
1 亿用户 × 365 天 = 365 亿行 → 不可能
核心:
SETBIT sign:2025:uid:123 100 1 # 第 100 天签到
BITCOUNT sign:2025:uid:123 # 今年累计签到天数
BITFIELD sign:2025:uid:123 GET u7 0 # 最近 7 天签到情况
连续签到天数
1. 拿到用户签到 BitMap(如 365 位)
2. 今天 = 第 200 天
3. BITFIELD 取最近 N 位
4. 从右往左数连续几个 1 → 连续签到天数
记忆锚
"签到=BitMap。SETBIT 签到,BITCOUNT 累计,BITFIELD 连续天数"
Q37:负载均衡——客户端 vs 服务端
| 服务端 LB | 客户端 LB | |
|---|---|---|
| 谁做决策 | LB(Nginx/K8s Service) | 客户端自己 |
| 客户端感知 | 只知道一个 VIP | 知道所有实例 IP |
| 额外跳转 | 多一跳(client→LB→server) | 直连(client→server) |
| 适用 | 外部流量/API 网关 | 微服务内部调用 |
| 例子 | Nginx, K8s Service, ALB | Dubbo, Ribbon, Kitex |
Dubbo 的客户端 LB
Consumer 从注册中心拿到 Provider 列表:[IP1, IP2, IP3]
→ 自己挑一个(随机/轮询/最少活跃)
→ 直连 Provider,不走网关
好处:少一跳(没有 LB 节点)
坏处:Consumer 需要注册中心 + LB 逻辑
记忆锚
"外部流量走 Nginx(服务端 LB),内部 RPC 走 Dubbo/Ribbon(客户端 LB)"
Q38:BASE 理论 vs ACID
| ACID | BASE | |
|---|---|---|
| 核心 | 强一致 | 最终一致 |
| 适用 | 单机事务/金融扣减 | 分布式/高并发/互联网 |
| 字母 | Atomicity, Consistency, Isolation, Durability | BAsically Available, Soft state, Eventually consistent |
| 例子 | 银行转账(扣 A 必须加 B) | 秒杀(库存暂扣,最终确认) |
BASE 详解
BA(基本可用):系统出问题时,核心功能可用(非核心降级)
S(软状态) :允许短暂不一致(缓存和 DB 可能不同步)
E(最终一致):经过一段时间,所有副本会一致(对账修复)
在游民系统的实践:
- 内容推荐:缓存数据 5s 过期(软状态),5s 后自动一致(最终一致)
- 内容子系统调用:熔断时返回缓存(基本可用),恢复后重新同步(最终一致)
Q39:游民系统的 AP/CP 权衡
TL;DR(口述版)
"游民系统整体是 AP 优先(保证可用性)的架构。
场景 1:业务 API 网关 网关——AP
→ 某个下游服务挂了 → 返回缓存数据 → 用户不白屏
→ 牺牲一致性(缓存可能是旧的),保证可用性
场景 2:用户资产——CP
→ 充值/扣款 → 数据库强一致(事务 + 行锁)
→ 宁可慢也不能错
场景 3:内容推荐——AP
→ 推荐挂了 → 返回热门内容(降级)
→ 牺牲个性化,保证有内容展示
Q40:秒杀系统补充 → 详见 B1 Q1,此处略。
总结
签到 → BitMap,SETBIT/BITCOUNT/BITFIELD,亿级用户 4.6GB
负载均衡 → 外部 Nginx(服务端LB),内部 Dubbo(客户端LB直连)
BASE → 基本可用+软状态+最终一致 — 互联网标配
游民 CAP → 整体 AP(可用性优先),资产 CP(一致性优先)
下一篇:B2 Spring Boot 深度面试题(12 题)