← 返回首页 📖 📖 Wiki知识库
📐 学习维度 本篇是 📖 📖 Wiki知识库 🏠 首页 🛤️ 学习路径 📚 全部文章

2026春招大厂面试真题补充 - 十二、系统设计方向真题补充5道

本文是 2026春招大厂面试真题补充 的分章阅读版。

十二、系统设计方向真题补充5道

1. 设计短链系统(字节/美团高频)


面试官: "设计一个短链系统,日活1亿,要求高可用。"

考察点: ID生成策略 + 缓存设计 + 重定向性能 + 数据一致性

标准回答框架:

1) 核心流程:
   生成: 长URL → 生成短码 → 存储 映射关系 → 返回短链
   访问: 短链 → 查询长URL → 301/302重定向

2) 短码生成策略:
   方案A: 自增ID + Base62编码
     ID=1 → Base62(1)="1", ID=10000 → Base62(10000)="2Bi"
     优点: 短/有序  缺点: 可预测(爬虫可遍历)
   方案B: MD5/SHA256哈希 + 取前6~7位
     优点: 不可预测  缺点: 可能冲突(需要去重检查)
   方案C: 雪花ID + Base62(推荐)
     优点: 分布式唯一 + 有序 + 不可预测

3) 架构图:
   ┌─────────┐    ┌──────────┐    ┌──────────┐
   │ Client  │───→│  Nginx   │───→│  App Svr │
   └─────────┘    └──────────┘    └────┬─────┘
                                      │
                           ┌──────────┼──────────┐
                           │          │          │
                       ┌───▼──┐  ┌───▼──┐  ┌───▼──┐
                       │Redis │  │MySQL │  │ Kafka│
                       │Cache │  │(分库) │  │(异步)│
                       └──────┘  └──────┘  └──────┘

4) 存储设计:
   MySQL分库分表: 按短码hash分16库×64表
   表结构: short_code(PK), long_url, create_time, expire_time, click_count

5) 性能优化:
   ① Redis缓存: 热门短链缓存(TTL=1天),命中率>95%
   ② 302重定向(非301): 302每次访问服务端,可统计点击量
   ③ 布隆过滤器: 快速判断短码是否存在(防重复,减少DB查询)
   ④ 异步统计: 点击数据先写Kafka → 批量写入ClickHouse

6) 面试话术: "短链系统核心是ID生成策略+缓存热点数据+异步统计。
   302重定向每次过服务端,方便统计;301会被浏览器缓存,省流量但无法统计"

避坑提示:
  - 别忘了说过期清理机制(定时任务删过期短链)
  - 别忘了说防滥用(同一长URL返回已有短链,不重复生成)

2. 设计Feed流系统(字节/腾讯高频)


面试官: "设计一个Feed流系统,类似微博/朋友圈。"

考察点: 推拉模型 + 时间线排序 + 写扩散vs读扩散

标准回答框架:

1) 核心模型选择:
   ┌──────────────────────────────────────────────┐
   │ 模式     │ 写放大 │ 读放大 │ 适用场景        │
   ├──────────┼────────┼────────┼─────────────────┤
   │ 推模式   │ 高     │ 低     │ 粉丝少的场景    │
   │(写扩散)  │ 发帖写N份 │ 读1次│ (朋友圈/普通用户) │
   ├──────────┼────────┼────────┼─────────────────┤
   │ 拉模式   │ 低     │ 高     │ 粉丝多的场景    │
   │(读扩散)  │ 发帖写1份 │ 读N次│ (明星/大V)     │
   ├──────────┼────────┼────────┼─────────────────┤
   │ 推拉结合 │ 中     │ 中     │ 生产环境        │
   │(混合)    │ 大V拉  │ 普通推 │ (微博/抖音)    │
   └──────────────────────────────────────────────┘

2) 数据结构:
   发帖表: post_id, user_id, content, create_time
   收件箱(推模式): user_id(关注者), post_id, create_time
   发件箱(拉模式): user_id(作者), post_id, create_time

3) Feed读取流程(推拉结合):
   ① 获取用户关注列表
   ② 普通用户: 直接读收件箱(Redis ZSet, score=时间戳)
   ③ 大V用户: 实时拉取发件箱最新帖子
   ④ 合并排序 → 返回Feed
   ⑤ 缓存优化: Redis缓存每个用户的Feed(Top 1000)

4) Redis存储:
   收件箱: ZSet, key=feed:{userId}, score=timestamp, member=post_id
   发件箱: ZSet, key=outbox:{userId}
   ZREVRANGEBYSCORE获取最新帖子

5) 面试话术: "推拉结合是Feed流的标准方案。
   普通用户用推模式(发帖时写所有粉丝收件箱),
   大V用拉模式(粉丝数>50万切拉,实时拉取发件箱)"

避坑提示:
  - 大V的定义标准要能动态调整(粉丝数阈值)
  - 取消关注时要清理收件箱中的帖子(异步清理)

3. 设计消息队列核心组件(阿里/字节高频)


面试官: "从零设计一个消息队列,核心组件怎么设计?"

考察点: 存储引擎设计 + 消费模型 + 高可用机制

标准回答框架:

1) 核心架构:
   ┌────────┐    ┌──────────────┐    ┌────────┐
   │Producer│───→│   Broker     │───→│Consumer│
   └────────┘    │ ┌──────────┐ │    └────────┘
                 │ │ CommitLog│ │     push/pull
                 │ │(顺序写)  │ │
                 │ └──────────┘ │
                 │ ┌──────────┐ │
                 │ │ ConsumeQ │ │
                 │ │(消费队列)│ │
                 │ └──────────┘ │
                 └──────────────┘
                      ↕
                 ┌──────────┐
                 │NameServer│(路由注册)
                 └──────────┘

2) 存储设计(参考Kafka/RocketMQ):
   ① CommitLog: 所有消息顺序追加写(一个物理文件), 写性能最高
   ② ConsumeQueue: 逻辑队列, 存消息在CommitLog的offset+size
   ③ IndexFile: 按Key索引, 支持按消息ID/Key查询

   为什么不每Topic一个文件?
   → 顺序写一个文件比写多个文件快得多(磁盘顺序写>随机写1000倍)
   → RocketMQ用CommitLog统一顺序写 + ConsumeQueue逻辑分Topic

3) 消费模型:
   ① Push模型(Broker推): 实时性好,但Broker压力大
   ② Pull模型(Consumer拉): Consumer自主控制,但有延迟
   ③ 长轮询(RocketMQ方案): Consumer发起请求→有消息立即返回→无消息hold 30s

4) 高可用:
   ① 主从复制: 同步双写(可靠)/异步复制(性能)
   ② 分区(Partition): Topic分多个Partition,分布在不同Broker
   ③ 消费者组: 同组内负载均衡,不同组独立消费

5) 面试话术: "消息队列核心是顺序写+零拷贝+分区并发。
   顺序写让磁盘性能媲美内存,零拷贝减少内核态拷贝,分区水平扩展"

避坑提示:
  - 别忘了说消息不丢失的保证(同步刷盘+同步复制+消费确认)
  - 要对比Kafka/RocketMQ的设计选择(为什么不同)

4. 设计限流系统(阿里/美团高频)


面试官: "设计一个分布式限流系统。"

考察点: 限流算法 + 分布式实现 + 动态配置

标准回答框架:

1) 算法选型:
   ┌────────────┬──────────┬──────────┬──────────┐
   │ 算法       │ 平滑性   │ 突发流量 │ 内存开销 │
   ├────────────┼──────────┼──────────┼──────────┤
   │ 固定窗口   │ 差       │ 2倍突发  │ O(1)     │
   │ 滑动窗口   │ 好       │ 无       │ O(N)     │
   │ 漏桶       │ 极好     │ 不允许   │ O(1)     │
   │ 令牌桶     │ 好       │ 允许     │ O(1)     │
   │ 滑动日志   │ 最好     │ 无       │ O(N)大   │
   └────────────┴──────────┴──────────┴──────────┘

2) 分布式令牌桶实现(Redis + Lua):
   -- acquire_token.lua
   local key = KEYS[1]
   local max_tokens = tonumber(ARGV[1])
   local rate = tonumber(ARGV[2])        -- 每秒补充令牌数
   local now = tonumber(ARGV[3])
   local requested = tonumber(ARGV[4])

   local info = redis.call('HMGET', key, 'tokens', 'last_time')
   local tokens = tonumber(info[1]) or max_tokens
   local last_time = tonumber(info[2]) or now

   -- 计算补充的令牌
   local elapsed = math.max(0, now - last_time)
   tokens = math.min(max_tokens, tokens + elapsed * rate)

   if tokens >= requested then
       tokens = tokens - requested
       redis.call('HMSET', key, 'tokens', tokens, 'last_time', now)
       redis.call('EXPIRE', key, math.ceil(max_tokens / rate) + 10)
       return 1  -- 允许
   else
       redis.call('HMSET', key, 'tokens', tokens, 'last_time', now)
       return 0  -- 拒绝
   end

3) 面试话术: "分布式限流核心是令牌桶+Redis Lua原子操作。
   注意Redis时间用服务端TIME命令,不用客户端时间(避免时钟不一致)"

避坑提示: 要提到集群限流vs单机限流的trade-off

5. 设计延迟任务系统(字节/美团高频)


面试官: "设计一个延迟任务系统,支持30分钟超时取消订单。"

考察点: 延迟队列实现 + 定时任务 + 多种方案对比

标准回答框架:

1) 方案对比:
   ┌─────────────┬──────────┬──────────┬──────────┐
   │ 方案        │ 精度     │ 可靠性   │ 适用规模 │
   ├─────────────┼──────────┼──────────┼──────────┤
   │ DelayQueue  │ ms       │ 进程内   │ 单机     │
   │ Redis ZSet  │ s        │ 中       │ 万级     │
   │ RocketMQ    │ s        │ 高       │ 百万级   │
   │ 时间轮      │ ms       │ 进程内   │ 高性能   │
   │ DB轮询      │ min      │ 高       │ 千级     │
   └─────────────┴──────────┴──────────┴──────────┘

2) Redis ZSet方案(最常用):
   生产: ZADD delay:tasks <timestamp+30min> <taskId>
   消费: 定时任务每秒执行
     ZRANGEBYSCORE delay:tasks 0 <currentTimestamp> LIMIT 0 100
     → 取出到期的任务 → 执行取消逻辑 → ZREM删除

   优化:
   ① 多消费者分片: 按taskId hash分多个ZSet
   ② 借鉴Redisson DelayQueue: 到期自动转移到目标Queue
   ③ Lua原子操作: ZRANGEBYSCORE + ZREM 原子执行

3) RocketMQ延迟消息方案(推荐):
   message.setDelayTimeLevel(16);  // 16级=30分钟
   // 延迟等级: 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m
   // RocketMQ 5.0+支持任意延迟时间

4) 面试话术: "中小规模用Redis ZSet(简单可控),
   大规模用RocketMQ延迟消息(可靠+不丢),
   单机高性能用时间轮(Netty HashedWheelTimer)"

避坑提示:
  - 要提到"到期后执行失败怎么办?" → 重试+死信队列+人工补偿
  - 不要只说一种方案,要对比分析trade-off

相关页面