面试题集锦:系统设计题

通识对照:CEX 风控域地图:准入、交易中、清算、出站与合规别揉成一个服务

面试题集锦:系统设计题

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% 无效流量)。

核心架构

interview system design qa · 图 1
interview system design qa · 图 1 · 点击查看 SVG 原图

关键设计决策

决策点方案为什么
库存扣减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 分配一个短索书号。

核心架构

interview system design qa · 图 2
interview system design qa · 图 2 · 点击查看 SVG 原图

关键设计决策

决策点方案为什么
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 订阅号拉取。

核心架构决定

interview system design qa · 图 3
interview system design qa · 图 3 · 点击查看 SVG 原图

❌ 误区

❌✅
"全部推模式,简单"大 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 是否已使用。

完整链路

interview system design qa · 图 4
interview system design qa · 图 4 · 点击查看 SVG 原图

三层防重对比

层级方案作用局限性
客户端按钮置灰 + 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)→ 记分员更新(聚合)→ 大屏幕即时显示(推送)。没有人去查数据库——全部在"现场"完成。

核心架构

interview system design qa · 图 5
interview system design qa · 图 5 · 点击查看 SVG 原图

关键设计决策

决策点方案为什么
订单簿存储内存有序 Map(TreeMap/SkipList)O(logN) 插入/删除,无需 DB 查询
K 线聚合内存滑动窗口 + 定时触发1min K 线 = 60s 窗口内 OHLC
推送方式WebSocket + 订阅模式长连接,用户只收订阅的币对
持久化异步 Kafka 落库不阻塞推送主链路
语言选择Go / C++ / RustGC 语言需调优(见 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)。

架构设计

interview system design qa · 图 6
interview system design qa · 图 6 · 点击查看 SVG 原图

聚合算法(增量更新)

// 每来一个 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),只收到自己频道的信号。

架构

interview system design qa · 图 7
interview system design qa · 图 7 · 点击查看 SVG 原图

关键设计点

设计点方案细节
连接模型异步非阻塞 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 + 本地缓存

interview system design qa · 图 8
interview system design qa · 图 8 · 点击查看 SVG 原图

原则:行情数据适合集中式存储 + 本地缓存,因为延迟敏感,一致性要求不如资金系统严格。

记忆锚

"Redis 做主存储,本地 Caffeine 做热缓存,Pub/Sub 做变更通知"


Q11:可水平扩展的行情数据历史存储与查询系统

TL;DR

历史行情 = 时序数据库(ClickHouse/InfluxDB/TDengine) 做主力存储 + 对象存储(S3) 做归档 + Redis 做最近热数据缓存。查询路由:最近 1 天查 Redis → 1 年查 ClickHouse → 全量查 S3。

类比

🗄️ 银行流水:最近 3 个月(Redis/热存储)随时查 → 去年流水(ClickHouse/温存储)稍慢但能查 → 10 年前流水(S3 归档/冷存储)需调档。

架构

interview system design qa · 图 9
interview system design qa · 图 9 · 点击查看 SVG 原图

降采样策略

原始数据: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 也能运很多人。

决策框架

interview system design qa · 图 10
interview system design qa · 图 10 · 点击查看 SVG 原图

行情场景具体取舍

取舍倾向原因
单条推送 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)。

类比

🏠 房产中介撮合:买家出价按从高到低排(买盘),卖家要价按从低到高排(卖盘)。最高买价 ≥ 最低卖价 → 成交!否则挂单等待。

模块划分

interview system design qa · 图 11
interview system design qa · 图 11 · 点击查看 SVG 原图

核心数据结构

// 订单簿:买盘用最大堆(价格最高在前),卖盘用最小堆(价格最低在前)
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 原子 DECR10 万 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)+ 订单簿不变(统一数据结构)+ 插件化注册(新增订单类型无需改撮合核心)。

架构

interview system design qa · 图 12
interview system design qa · 图 12 · 点击查看 SVG 原图

策略模式设计

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 GCChronicle Queue / MapDB
ZGCP99 停顿 < 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用户"
}

热更新机制

interview system design qa · 图 13
interview system design qa · 图 13 · 点击查看 SVG 原图

关键:热更新必须是原子切换——新规则编译完成后,一个指针/引用切换就生效,不能出现"一半新一半旧"的状态。

记忆锚

"DSL + 优先级短路 + 原子热切换 + 降级兜底"


Q21:设计高性能准实时全球用户资产持仓快照服务

TL;DR

持仓快照 = 账户服务变更事件 → Kafka → 实时计算 → Redis(热)+ DB(持久)。核心挑战:全球部署下的延迟 + 一致性 + 海量用户。

类比

📸 Google Photos 的"实时相册":你每拍一张照片(账户变更),后台自动更新你的"相册封面图"(持仓快照)。你打开相册 App 时(查询快照),看到的永远是最新的封面,不需要每次重新扫描所有照片。

架构

interview system design qa · 图 14
interview system design qa · 图 14 · 点击查看 SVG 原图

核心设计

实时路径(毫秒级):
  交易成交 → 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)+ 灰度切流。第一阶段不改核心逻辑,只做接口标准化;第二阶段逐步替换老系统模块;第三阶段全量切换。

类比

🏗️ 上海外滩隧道改造:不能封路施工(业务不能停)。方案:在旁边挖一条新隧道(新系统并行跑),逐步切换车流(灰度切流),老隧道最后废弃。

三步走策略

interview system design qa · 图 15
interview system design qa · 图 15 · 点击查看 SVG 原图

技术选型矩阵

组件老系统新选型原因
规则引擎Drools自研轻量 DSL热更新更快,依赖更少
特征存储MySQLRedis + 本地缓存降低延迟 10x
消息队列RabbitMQKafka吞吐量提升,分区有序
模型服务Python FlaskTriton/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-AliveQPS +200%
序列化优化Protobuf 替代 JSON带宽 -60%

记忆锚

"本地缓存 + 预编译 + 异步补全 + Protobuf"


Q25:风控系统超时/报错如何避免影响交易?

TL;DR

Fail-open 策略:风控挂了 → 放行交易(而非阻断)。核心机制:熔断器(连续超时 N 次 → 跳过风控直接放行)→ 超时降级(超时 50ms → 返回默认 PASS) → 事后审计补偿(放行的交易异步重新检查)。

类比

🏥 急诊室分诊:正常流程是挂号→问诊→检查→开药。如果挂号系统挂了,急诊室不会让病人等死——直接让医生先看(fail-open),系统恢复后再补录挂号信息(事后补偿)。

决策树

interview system design qa · 图 16
interview system design qa · 图 16 · 点击查看 SVG 原图

熔断器配置

连续失败 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
CPUtick 处理延迟 × 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)。

架构

interview system design qa · 图 17
interview system design qa · 图 17 · 点击查看 SVG 原图

优化要点

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 恢复)。

架构

interview system design qa · 图 18
interview system design qa · 图 18 · 点击查看 SVG 原图

容错机制

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, ALBDubbo, Ribbon, Kitex

Dubbo 的客户端 LB

Consumer 从注册中心拿到 Provider 列表:[IP1, IP2, IP3]
→ 自己挑一个(随机/轮询/最少活跃)
→ 直连 Provider,不走网关

好处:少一跳(没有 LB 节点)
坏处:Consumer 需要注册中心 + LB 逻辑

记忆锚

"外部流量走 Nginx(服务端 LB),内部 RPC 走 Dubbo/Ribbon(客户端 LB)"


Q38:BASE 理论 vs ACID

ACIDBASE
核心强一致最终一致
适用单机事务/金融扣减分布式/高并发/互联网
字母Atomicity, Consistency, Isolation, DurabilityBAsically 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 题)