跳到主要内容
目录

封底估算:把系统设计的第一分钟花在算数量级上

封底估算不是面试技巧,是系统设计的第一道算术题。系统设计面试的第一分钟通常在聊需求澄清,但真正决定一个方案能不能做的,是数量级——流量有多大、单机扛不扛得住、存储要几个 PB、可用性能不能给。这些数字用不着精确,用不着精确恰恰是重点:如果一个方案的估算结果差着三四个数量级,那它就不值得继续设计。

这篇整理自 Alex Xu《System Design Interview — An Insider’s Guide》第 2 章「Back-of-the-Envelope Estimation」的中文笔记(译本仓库,英文原笔记见 liquidslr/system-design-notes)。原文的估算方法讲得完整,但有三处口径在今天已经不准或没说清,文章里会逐条指出并给出实测/官方依据。

一、封底估算在解什么问题

估算不是猜,是用最少的算术排除掉不可行的方向。它有三个特征:

  • 精度不重要,量级重要。 讲义给的口诀是「精确度不重要,重点是估算过程」,并给了个例子:99987 / 9.1 可以近似成 100000 / 10 = 10000。
  • 假设要写下来。 估算的依据必须能被复核,否则三个月后没人知道这个数字从哪来。
  • 单位要标清楚。 讲义明确要求「用 5 MB 而不是 5」——因为 MB 和 MiB 差 4.86%。

写清楚你的假设,承担一切「不明确」的后果。

讲义还列了四类常见估算场景:QPS(每秒查询数)、峰值 QPS、存储需求、缓存需求、服务器数量。这几类几乎覆盖了系统设计里所有「先算个数」的场合。

2 的幂

讲义给的第一件工具是 2 的幂表,因为存储和带宽的单位换算全是 2 的幂:

换算精确值近似
2^101,024 KB1 MB
2^201,048,576 MB1 GB
2^301,073,741,824 GB1 TB
2^401,099,511,627,776 TB1 PB

用 2 的幂算,误差在 5% 以内;用十进制算,你会得到 1 PB = 1,000 TB 这种混着两套进制的数,后面乘起来误差就不受控了。

二、延迟数字:原文的表已经过时了

讲义第二节给了「每个程序员都应该知道的延迟数字」表,并标注了年份 2020:

操作原文数值(2020)
L1 缓存访问0.5 ns
L2 缓存访问7 ns
主内存访问100 ns
SSD 随机读150 µs
HDD 随机寻道10 ms
数据中心内往返500 µs
跨区域数据中心150 ms

这张表的用法是比相对量级:内存比磁盘快,磁盘寻道要避开,跨区域往返是同机房的一百倍。但它是 2020 年的数字,今天已经不能直接引用了。

我在本机(2026)实测了一遍

下面这段 C 代码用指针追逐(pointer chasing)测延迟:随机访问一个数组,每次用上一次的取值当下标。这条依赖链无法被 CPU 预取或乱序执行,只能一级一级等,所以测出来的是真实的访存延迟。

/* 指针追逐测各级存储延迟。
   关键:a 必须是覆盖全部 n 个元素的【单一哈密顿环】。
   随机置换会分解成许多短环,从 idx=0 出发只碰到其中一条 → 访问集中在
   一小片地址里,测出来的是缓存命中而不是真实延迟。 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>

static uint64_t st = 88172645463325252ULL;
static inline uint64_t xs64(void){ st^=st<<13; st^=st>>7; st^=st<<17; return st; }
static volatile uint64_t sink;

static double measure(uint64_t *a, size_t iters){
    uint64_t idx=0; struct timespec t0,t1;
    clock_gettime(CLOCK_MONOTONIC,&t0);
    for(size_t i=0;i<iters;i++) idx=a[idx];
    clock_gettime(CLOCK_MONOTONIC,&t1);
    sink=idx;
    return ((t1.tv_sec-t0.tv_sec)*1e9+(t1.tv_nsec-t0.tv_nsec))/iters;
}

int main(int argc,char**argv){
    size_t kb=(size_t)atol(argv[1]);
    size_t bytes=kb*1024, n=bytes/sizeof(uint64_t);
    uint64_t *a=(uint64_t*)malloc(bytes), *p=(uint64_t*)malloc(n*sizeof(uint64_t));
    if(!a||!p){fprintf(stderr,"malloc failed\n");return 1;}
    for(size_t i=0;i<n;i++) p[i]=i;
    for(size_t i=n-1;i>0;i--){ size_t j=xs64()%(i+1); uint64_t t=p[i]; p[i]=p[j]; p[j]=t; }
    for(size_t i=0;i<n-1;i++) a[p[i]]=p[i+1];      /* 连成单一长环 */
    a[p[n-1]]=p[0];
    size_t len=0,cur=0; while(a[cur]!=0 && len<=n){ cur=a[cur]; len++; }
    size_t iters = bytes<=65536 ? 30000000 : (bytes<=1048576 ? 12000000 : 6000000);
    double best=1e18;
    for(int t=0;t<5;t++){ double d=measure(a,iters); if(d<best) best=d; }
    printf("%9zu KB  %8.2f ns/access  (环长 %zu/%zu)\n", kb, best, len, n);
    free(a); free(p); return 0;
}

在本机(Apple M3 Pro,12 核,36 GB,L1d 64 KB)实跑:

       32 KB      1.03 ns/access  (环长 4095/4096)
      128 KB      1.02 ns/access  (环长 16383/16384)
      512 KB      5.22 ns/access  (环长 65535/65536)
      2048 KB      6.04 ns/access  (环长 262143/262144)
      8192 KB      8.79 ns/access  (环长 1048575/1048576)
     32768 KB     59.64 ns/access  (环长 4194303/4194304)
    131072 KB    103.69 ns/access  (环长 16777215/16777216)
    524288 KB    111.24 ns/access  (环长 67108863/67108864)

对着原文那张表读,有几处值得注意:

  • 512 KB 以内都在 1 ns 上下——M3 Pro 的 L2/SLC 缓存足够大,这一档比 2020 年那张表里「L2 = 7 ns」乐观得多。
  • 从 32 MB 到 128 MB 是断崖:9.15 ns → 64.58 ns → 105.85 ns。原文的「主内存 100 ns」对应的是最后那个平台,但要走到 100 ns,工作集得超过 128 MB。
  • 换句话说,今天「内存访问」的真实代价取决于你有没有把工作集装进缓存,这比 2020 年那张固定数字表有用得多。

(这些是墙钟实测,重跑一遍会有几个百分点的抖动;台阶的位置稳定,个位数不必当真。)

顺便记一个我在写这段代码时踩的坑,因为它会让整个测量失效:指针追逐的数组必须是覆盖全部元素的单一长环。最初我用 a[i] = rand() % n 生成下标,结果随机置换分解成了许多短环,从 idx=0 出发只走其中一条,访问集中在一小片地址里——测出来全是 1 ns 上下,看着还挺漂亮,实际上测的是缓存命中。改成 Fisher-Yates 洗牌后首尾相接、校验环长等于 n,曲线才显出真实的台阶。代码里那句 while(a[cur]!=0 && len<=n) 就是这个校验:它从下标 0 出发数到再次回到 0,打印出的 环长 是走过的步数,所以必须等于 n−1(少一个是因为最后一步回到了起点)——否则说明链断成了短环,访问仍集中在一小片地址里,数字不作数。

估算用到的延迟数字,应该在自己的目标机器上实测,而不是抄表。 抄来的表是别人的 CPU、别人的年份。

三、可用性 nines:原文用的是年度口径,SLA 用的是月度

讲义给的第二张表是可用性 nines:

可用性原文给的年度停机时间
99%(两个 9)约 3.65 天/年
99.9%(三个 9)约 8.8 小时/年
99.99%(四个 9)约 52 分钟/年
99.999%(五个 9)约 5.3 分钟/年
99.9999%(六个 9)约 31.56 秒/年

这张表算得没错——复算一遍(365.25 天/年)能得到同样的数。但它有个没说清的口径问题,而这个口径直接决定你会不会误判自己的架构:

这些数字是「一年」的,但云厂商的 SLA 承诺是「一个月」的。

AWS EC2 的 Service Level Agreement 原文写得很明确:区域级 SLA 是「Monthly Uptime Percentage of at least 99.99%, in each case during any monthly billing cycle」,而且「Monthly Uptime Percentage」的定义是「subtracting from 100% the percentage of minutes during the month」。

同一个「99.99%」,两种口径差 12 倍:

可用性年度口径允许停机月度窗口允许停机
99.99%8.77 小时43.83 分钟
99.999%52.60 分钟4.38 分钟
99.9999%5.26 分钟26.30 秒

这条差别会改变结论。 原文那张「99.99% = 52 分钟/年」的表,让人以为扛住 52 分钟的停机就算达标;但按 AWS 的月度口径,43.83 分钟就违约了。更要命的是,AWS 对单台实例的承诺低得多:Instance-Level SLA 是 99.5%(月度),区域级才是 99.99%。也就是说,一台机器一个月停机 3.65 小时仍然合规,但你如果按区域级去设计冗余,就会误判自己的容错成本。

中国云厂商的承诺口径也不一样

顺手核了阿里云 ECS 的 服务等级协议(2026 年 7 月修订、9 月生效版),它的口径同样按自然月,但承诺值与 AWS 不同:

维度阿里云 ECSAWS EC2
单实例99.975%99.5%
多可用区99.995%99.99%(区域级)
赔偿方式代金券服务信用(抵扣未来账单)

两个细节值得记:

  1. 阿里云单实例的承诺(99.975%)比 AWS 单实例(99.5%)高得多,但多可用区维度反而略低(99.995% vs 99.99%——这里阿里云更高)。所以「哪家云更可靠」这种问法本身就不成立,得先问是哪个维度。
  2. 赔偿方式不是钱:阿里云给代金券(且代金券有有效期),AWS 给服务信用(抵扣未来账单,最低 1 美元、不给现金)。真出故障时,赔偿形式对现金流的影响和百分比一样重要。
  3. 阿里云还定义了一个容易被忽略的细节:单实例不可用要求「与任一 IP 地址的双向都无法联通,且该状态持续一分钟以上」——也就是必须持续满一分钟才计入,秒级抖动不算。这直接改变了「哪些故障算 SLA 违约」的判定。

估算可用性时,先确认口径是月度还是年度、是单实例还是多可用区、赔偿是钱还是代金券。 这三个问题不问清,nines 表就只是一串好看的数字。

四、走一遍完整的估算:Twitter 的 QPS 与存储

讲义第二节给了一个完整例子,假设是:3 亿月活、50% 日活、每用户每天 2 条推、10% 的推文含媒体、数据保留 5 年。

复算一遍(讲义的数字都对):

# 讲义第 2 章的估算例子复算:Twitter 的 QPS 与存储
MAU = 300_000_000
DAU_RATIO = 0.5
TWEETS_PER_USER_PER_DAY = 2
MEDIA_RATIO = 0.10
MEDIA_BYTES = 1_000_000          # 1 MB(十进制)
RETENTION_DAYS = 365 * 5

dau = MAU * DAU_RATIO
avg_qps = dau * TWEETS_PER_USER_PER_DAY / 86400
peak_qps = 2 * avg_qps

media_per_day = dau * TWEETS_PER_USER_PER_DAY * MEDIA_RATIO * MEDIA_BYTES
media_5y = media_per_day * RETENTION_DAYS

print(f"DAU            = {dau/1e6:.0f} M")
print(f"平均发推 QPS    = {avg_qps:.0f}")
print(f"峰值 QPS (2x)  = {peak_qps:.0f}")
print(f"媒体存储/天     = {media_per_day/1e12:.0f} TB")
print(f"5 年媒体存储    = {media_5y/1e15:.1f} PB")
DAU            = 150 M
平均发推 QPS    = 3472
峰值 QPS (2x)  = 6944
媒体存储/天     = 30 TB
5 年媒体存储    = 54.8 PB

讲义给的答案是 ~3500 / ~7000 / 30TB / ~55PB,逐项对得上。

但估算真正有用的地方在于你接着要问的问题。把 55 PB 拆开:

  • 副本几份? 3 副本就是 165 PB。讲义没提这一层,但它对存储账单和机房规划的影响比存储估算本身还大。
  • 含不含元数据与索引? 上面的 55 PB 只有媒体。推文正文、用户关系、时间线索引都不在里面——而这些恰恰是真正需要随机读的部分。
  • 压缩过吗? 讲义的关键洞察之一是「在互联网上传输数据前先压缩」,但它没把压缩算进存储估算里。媒体能不能再压 20%,直接决定这 55 PB 要不要写成 44 PB。

这几个问题原文没说,但它们才是估算的落点。估算的价值不在那个数字本身,而在于它逼你把假设一条条摊开。

五、四条技巧,落到具体动作

讲义第三节给的四条技巧,逐条翻译成能做的事:

1. 取整与近似

用整数简化计算:99987 / 9.1 ≈ 100000 / 10 = 10000。

动作:算之前先判断误差预算。如果最终答案是「要不要上这个方案」,那你需要的是数量级对,1.5 倍和 2 倍的差别无关紧要;如果是「买几台机器」,你需要 10% 以内的精度,此时再取整就晚了。

2. 写下假设

讲义说「把假设清楚地记录下来,以备将来参考」。

动作:估算表里必须有一列「假设」,每条假设要有来源(本机实测 / 官方 SLA / 业务给的数)。没有来源的假设就是猜测,而猜测在方案评审时会被当成结论用。

3. 标注单位

讲义说「通过标注单位避免歧义(例如用 5 MB 而不是 5)」。

动作:写 5 MB 还是 5 MiB 是个真问题。1 MB = 10^6 字节,1 MiB = 2^20 字节,差 4.86%。刚才那个推文存储的例子,1 MB 和 1 MiB 会让 5 年结果从 54.8 PB 变成 56.4 PB——看起来是同一个设计,账单差 3%。

4. 常见估算场景

QPS、峰值 QPS、存储、缓存、服务器数量。

动作:估算服务器数量时别忘了 Little’s Law——并发数 = 到达率 × 平均停留时间。知道 QPS 和单请求耗时,就能反推要多少并发;反过来,知道并发上限也能反推单请求耗时的红线。

六、它不解决什么

  • 它不替代实测。 估算告诉你「单机大概能扛 10 万 QPS」,实测告诉你「在你的负载分布下能扛 8 万」,差的这 20% 就是要压测的地方。
  • 它不覆盖尾延迟。 均值能算出来,P99 不能。估算解决的是「方案可不可行」,不是「性能够不够好」。
  • 它不能替你做取舍。 估算给出的是选项的代价,不是该选哪个。

FAQ(六、常见问题)

封底估算和压测是什么关系?

分工不同。估算在设计之前,用最粗的算术排除不可行的方向——比如算出需要 500 PB 存储时你会立刻停下来重新设计。压测在设计之后,验证估算的方向对不对、边界在哪。顺序不能反:先压测再估算,等于用最贵的方法回答「这个方案能不能做」。

估算到多少精度才够?

看你用它做什么决定。决定「要不要做这个方案」,数量级对就够;决定「买几台机器、预留多少带宽」,需要 10% 以内。更细的精度要用实测拿,不是在纸上多算几位。

有了云厂商的 SLA,还要自己估算可用性吗?

要,但目的不同。云厂商的 SLA 是它的承诺,你的架构目标是自己的期望。两者可能不一致:AWS 单实例承诺 99.5%,如果你给单机业务做 99.99% 的期望,就必须自己加冗余——而加冗余的代价,正是估算要回答的问题。

nines 到底该看几个?

看你能承担多少停机。从 99.9% 开始,但先算一遍月度口径下的停机分钟数(99.9% ≈ 43.8 分钟/月),再对照你的业务:一次故障 40 分钟会怎样?答不上来的话,nines 数字再好看也没有意义。

延伸阅读

出处与许可

  • 原始出处:Alex Xu《System Design Interview — An Insider’s Guide》(Vol 1 & 2, 2nd Ed.),第 2 章「Back-of-the-Envelope Estimation」。原书为商业出版物,版权归作者所有。
  • 本文所据的中文笔记:lukeTheNeuromancer/system-design-notes-zh(社区翻译版)与英文原笔记 liquidslr/system-design-notes。这两个仓库均未附带任何 LICENSE 文件(GitHub API 返回 license: null),即未获任何转载或改编授权。
  • 因此本文的处理:仅做方法层面的译述与讨论,不转载、不改编原书或两个笔记仓库的正文;引用限于概念、公式与数据表的口径说明,并逐处标明来源。全部技术内容以本文自己的实测、复算与官方文档为依据。
  • 本文自有的增量(占正文主体):① 2026 年本机(Apple M3 Pro)的缓存/内存延迟实测与代码,含指针追逐写法的正确性陷阱;② 可用性 nines 的月度窗口 vs 年度窗口口径辨析,及 AWS 与阿里云 SLA 的一手原文对照;③ Twitter 估算例子的可执行复算脚本,以及讲义未覆盖的副本数、元数据、压缩三层追问;④ 单位标注(MB vs MiB)对估算结果的具体影响。
  • 未经原作者授权。如需正式引用原书内容,请购买原书并遵守其版权条款。
赞赏

如果这篇文章帮到了你,欢迎请我喝杯咖啡。

  • 微信赞赏二维码,用微信扫一扫

    微信支付

  • 支付宝赞赏二维码,用支付宝扫一扫

    支付宝

金额随意,感谢支持

赞赏

如果这篇文章帮到了你,欢迎请我喝杯咖啡。

  • 微信赞赏二维码,用微信扫一扫

    微信支付

  • 支付宝赞赏二维码,用支付宝扫一扫

    支付宝

金额随意,感谢支持