封底估算不是面试技巧,是系统设计的第一道算术题。系统设计面试的第一分钟通常在聊需求澄清,但真正决定一个方案能不能做的,是数量级——流量有多大、单机扛不扛得住、存储要几个 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^10 | 1,024 KB | 1 MB |
| 2^20 | 1,048,576 MB | 1 GB |
| 2^30 | 1,073,741,824 GB | 1 TB |
| 2^40 | 1,099,511,627,776 TB | 1 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 不同:
| 维度 | 阿里云 ECS | AWS EC2 |
|---|---|---|
| 单实例 | 99.975% | 99.5% |
| 多可用区 | 99.995% | 99.99%(区域级) |
| 赔偿方式 | 代金券 | 服务信用(抵扣未来账单) |
两个细节值得记:
- 阿里云单实例的承诺(99.975%)比 AWS 单实例(99.5%)高得多,但多可用区维度反而略低(99.995% vs 99.99%——这里阿里云更高)。所以「哪家云更可靠」这种问法本身就不成立,得先问是哪个维度。
- 赔偿方式不是钱:阿里云给代金券(且代金券有有效期),AWS 给服务信用(抵扣未来账单,最低 1 美元、不给现金)。真出故障时,赔偿形式对现金流的影响和百分比一样重要。
- 阿里云还定义了一个容易被忽略的细节:单实例不可用要求「与任一 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 数字再好看也没有意义。
延伸阅读
- 基础篇:系统设计的三层 — 从单机到跨机的三层心智模型,估算题往往落在哪一层
- 相关:高性能开发参考手册 — 本文只测了延迟阶梯的一角,尾延迟与抖动在那份手册里
- 原文:System Design Interview — An Insider’s Guide 第 2 章(Alex Xu 著,商业出版物;本文的中文笔记来自社区翻译仓库,未获原作者授权转载)
出处与许可
- 原始出处: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)对估算结果的具体影响。
- 未经原作者授权。如需正式引用原书内容,请购买原书并遵守其版权条款。