设计分布式系统时,「这个 ID 怎么生成」听起来是个小问题。但唯一 ID 生成器同时要满足唯一、有序、64 位内、每秒一万个——这四个约束互相挤着,选错了不是性能问题,是数据要重写的问题。它的核心权衡,都在这些约束的配比里。
这篇整理自 Alex Xu《System Design Interview — An Insider’s Guide》第 7 章「Design a Unique ID Generator in Distributed Systems」的中文笔记(译本仓库,英文原笔记见 liquidslr/system-design-notes)。原章把四种方案的取舍列得很清楚,Snowflake 的位分配也写得准确——但没有一个数字被算过:「10,000 ID/秒」需要多少台机器?41 位时间戳什么时候耗尽?时钟回拨到底会不会撞 ID?文章里我把这些全部实现并测了出来,其中一条结论和常见理解相反。
一、四种方案,先把账算清楚
原章列的四个方案,评价都很准。补上各自的容量账:
| 方案 | 唯一性来源 | 能否时间有序 | 中心化瓶颈 |
|---|---|---|---|
多主复制 auto_increment | 步长分配 | 勉强(各主键独立递增) | 数据库 |
| UUID | 全局随机 | 否 | 无 |
| 票据服务器 | 中心发号 | 是 | 单点 |
| Snowflake | 时间戳 + 机器号 + 序列号 | 是 | 无 |
票据服务器的致命点不是「慢」,而是它是单点:它挂了,整个系统发不出 ID。这个问题在很多场景下被低估了——发号服务一旦成为关键路径上的同步依赖,它的可用性就等于整个系统的可用性。
二、Snowflake 的位布局:把它算到底
原章给的布局是:符号位 1 + 时间戳 41 + 数据中心 5 + 机器 5 + 序列号 12 = 64 位。这个划分看起来是拍脑袋定下来的,其实每一段都对应一个可算的量。下面是一个可运行的实现(Python,纯标准库):
# -*- coding: utf-8 -*-
"""唯一 ID 生成器:Snowflake 的位布局、吞吐、时钟回拨,以及段长度调优。"""
import time
EPOCH = 1288834974657 # 2010-11-04 01:42:54.657 UTC
NOW = 1794972006150 # 固定的「现在」,让输出可复现
TS_BITS, DC_BITS, WK_BITS, SEQ_BITS = 41, 5, 5, 12
MAX_SEQ = (1 << SEQ_BITS) - 1
TS_MAX = (1 << TS_BITS) - 1
WK_SHIFT = SEQ_BITS # 机器号 bit 12..16
DC_SHIFT = SEQ_BITS + WK_BITS # 数据中心 bit 17..21
TS_SHIFT = SEQ_BITS + WK_BITS + DC_BITS # 时间戳 bit 22..62
class Clock:
def now_ms(self):
return int(time.time() * 1000)
class FixedClock(Clock):
"""固定时钟:让本块的输出完全可复现,便于逐行比对。"""
def __init__(self, ms=NOW):
self.ms = ms
def now_ms(self):
return self.ms
class Snowflake:
"""带时钟回拨保护的标准实现。"""
def __init__(self, worker_id=0, datacenter_id=0, clock=None):
assert 0 <= worker_id < (1 << WK_BITS)
assert 0 <= datacenter_id < (1 << DC_BITS)
self.worker_id = worker_id
self.datacenter_id = datacenter_id
self.clock = clock or Clock()
self.sequence = 0
self.last_ts = -1
def next_id(self):
ts = self.clock.now_ms()
if ts < self.last_ts:
raise RuntimeError(f"clock moved backwards: {self.last_ts} -> {ts}")
if ts == self.last_ts:
self.sequence = (self.sequence + 1) & MAX_SEQ
if self.sequence == 0:
while ts <= self.last_ts:
ts = self.clock.now_ms()
else:
self.sequence = 0
self.last_ts = ts
return (((ts - EPOCH) << TS_SHIFT)
| (self.datacenter_id << DC_SHIFT)
| (self.worker_id << WK_SHIFT)
| self.sequence)
@staticmethod
def decode(iid):
ts = (iid >> TS_SHIFT) + EPOCH
return {
"timestamp_ms": ts,
"datetime": time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(ts / 1000)),
"datacenter_id": (iid >> DC_SHIFT) & ((1 << DC_BITS) - 1),
"worker_id": (iid >> WK_SHIFT) & ((1 << WK_BITS) - 1),
"sequence": iid & MAX_SEQ,
}
def naive_next_id(ts, worker_id, datacenter_id, state):
"""有 bug 的常见实现:时钟回拨后序列号直接归零,不检查该时间戳是否用过。"""
if ts != state["last_ts"]:
state["seq"] = 0
else:
state["seq"] = (state["seq"] + 1) & MAX_SEQ
state["last_ts"] = ts
return (((ts - EPOCH) << TS_SHIFT)
| (datacenter_id << DC_SHIFT)
| (worker_id << WK_SHIFT)
| state["seq"])
if __name__ == "__main__":
print("=== 1. 41 位时间戳能撑到什么时候 ===")
exhaustion = EPOCH + TS_MAX
print(f" 纪元 = {EPOCH} ({time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(EPOCH / 1000))} UTC)")
print(f" 上限 = {TS_MAX} ms ≈ {TS_MAX / 1000 / 86400 / 365.25:.2f} 年")
print(f" 耗尽 = {exhaustion} ({time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(exhaustion / 1000))} UTC)")
print(f" 距今 {(exhaustion - NOW) / 1000 / 86400 / 365.25:.1f} 年")
print("\n=== 2. 段长度调优:换一种分配会怎样 ===")
print(f"{'时间戳':>6}{'机器':>6}{'序列':>6}{'机器总数':>10}{'单机ID/秒':>14}{'可用年数':>10}{'耗尽日期':>14}")
for ts_bits, wk_bits, seq_bits in [(41, 10, 12), (41, 10, 10), (41, 12, 10),
(42, 10, 12), (43, 10, 11), (41, 8, 15)]:
dc_bits = 2
machines = 1 << (wk_bits + dc_bits)
per_sec = (1 << seq_bits) * 1000
ts_max = (1 << ts_bits) - 1
print(f"{ts_bits:>6}{wk_bits:>6}{seq_bits:>6}{machines:>10,}{per_sec:>14,}"
f"{ts_max / 1000 / 86400 / 365.25:>10.1f}"
f"{time.strftime('%Y-%m-%d', time.gmtime((EPOCH + ts_max) / 1000)):>14}")
print("\n=== 3. 需求反推:给定机器数与峰值 QPS,需要多少序列位 ===")
for machines_total, qps in [(1024, 10_000), (1024, 100_000), (256, 1_000_000)]:
per_machine_qps = qps / machines_total
need_per_ms = per_machine_qps / 1000
bits = 0
while (1 << bits) < max(need_per_ms, 1):
bits += 1
cap = (1 << bits) * 1000
note = "序列号恒为 0" if bits == 0 else f"每毫秒 {1 << bits:,} 个"
print(f" {machines_total:>5} 台 / 峰值 {qps:>9,} QPS -> 每台 {per_machine_qps:>8.2f} QPS"
f" -> {bits} 位序列号({note},容量 {cap:,} ID/秒,余量 {cap / per_machine_qps:.0f} 倍)")
print("\n=== 4. 位布局实测(worker=7, dc=3)===")
sf = Snowflake(worker_id=7, datacenter_id=3, clock=FixedClock())
iid = sf.next_id()
print(f" ID = {iid}")
print(f" bin = {iid:064b}")
for k, v in sf.decode(iid).items():
print(f" {k:<16} = {v}")
d = sf.decode(iid)
assert d["worker_id"] == 7 and d["datacenter_id"] == 3
print(" 自检:worker_id / datacenter_id 解码与传入一致 ✓")
print("\n=== 5. 时钟回拨:朴素实现真的会产出重复 ID ===")
base_ts = 1700000000000
state = {"last_ts": -1, "seq": 0}
first = [naive_next_id(base_ts, 1, 1, state) for _ in range(5)]
print(f" 时刻 T 生成 5 个: 序列号 {[i & MAX_SEQ for i in first]}")
naive_next_id(base_ts - 500, 1, 1, state) # 时钟回拨 500 ms
again = [naive_next_id(base_ts, 1, 1, state) for _ in range(5)]
print(f" 回拨后再到时刻 T: 序列号 {[i & MAX_SEQ for i in again]}")
dup = set(first) & set(again)
print(f" 重复 ID 数 = {len(dup)} -> {'会撞!' if dup else '不会撞'}")
实跑结果:
=== 1. 41 位时间戳能撑到什么时候 ===
纪元 = 1288834974657 (2010-11-04 01:42:54 UTC)
上限 = 2199023255551 ms ≈ 69.68 年
耗尽 = 3487858230208 (2080-07-10 17:30:30 UTC)
距今 53.6 年
=== 2. 段长度调优:换一种分配会怎样 ===
时间戳 机器 序列 机器总数 单机ID/秒 可用年数 耗尽日期
41 10 12 4,096 4,096,000 69.7 2080-07-10
41 10 10 4,096 1,024,000 69.7 2080-07-10
41 12 10 16,384 1,024,000 69.7 2080-07-10
42 10 12 4,096 4,096,000 139.4 2150-03-18
43 10 11 4,096 2,048,000 278.7 2289-07-30
41 8 15 1,024 32,768,000 69.7 2080-07-10
=== 3. 需求反推:给定机器数与峰值 QPS,需要多少序列位 ===
1024 台 / 峰值 10,000 QPS -> 每台 9.77 QPS -> 0 位序列号(序列号恒为 0,容量 1,000 ID/秒,余量 102 倍)
1024 台 / 峰值 100,000 QPS -> 每台 97.66 QPS -> 0 位序列号(序列号恒为 0,容量 1,000 ID/秒,余量 10 倍)
256 台 / 峰值 1,000,000 QPS -> 每台 3906.25 QPS -> 2 位序列号(每毫秒 4 个,容量 4,000 ID/秒,余量 1 倍)
=== 4. 位布局实测(worker=7, dc=3)===
ID = 2122892575739637760
bin = 0001110101110110000001111000110011010001010001100111000000000000
timestamp_ms = 1794972006150
datetime = 2026-11-18 03:20:06
datacenter_id = 3
worker_id = 7
sequence = 0
自检:worker_id / datacenter_id 解码与传入一致 ✓
=== 5. 时钟回拨:朴素实现真的会产出重复 ID ===
时刻 T 生成 5 个: 序列号 [0, 1, 2, 3, 4]
回拨后再到时刻 T: 序列号 [0, 1, 2, 3, 4]
重复 ID 数 = 5 -> 会撞!41 位时间戳够用多久
2080 年 7 月 10 日——从今天算还有 53.6 年。这是原章没提但必须知道的事:Snowflake 的 41 位时间戳是有限资源,用完那一刻所有 ID 生成器同时停止工作。好消息是这个期限足够长,多数系统根本不用管。
「10,000 ID/秒」其实是个很小的需求
序列号 12 位 → 每毫秒 4096 个 ID → 单机理论上限 409.6 万 ID/秒。原章要求「每秒超过 10,000 个 ID」,这个需求单机就能满足 409 倍。
第 3 组数据把这个反差显示得更彻底:1024 台机器、峰值 10,000 QPS 时,每台机器每秒才 9.77 个 ID——序列号 0 位就够了(序列号恒为 0,容量 1000 ID/秒,余量 102 倍)。也就是说原章的「10,000 ID/秒」这个需求数字,在真实分布式规模下几乎不需要序列号。序列号 12 位是为「单机扛住极高并发」准备的余量,不是分布式场景的必要条件。
单机吞吐
位分配决定了上限,实际吞吐还要看实现。同一份代码在 2026 年的笔记本上单线程实测(Python,纯标准库):
# -*- coding: utf-8 -*-
"""Snowflake 单线程吞吐实测。"""
import time
EPOCH = 1288834974657
SEQ_BITS, WK_BITS, DC_BITS = 12, 5, 5
MAX_SEQ = (1 << SEQ_BITS) - 1
WK_SHIFT = SEQ_BITS
DC_SHIFT = SEQ_BITS + WK_BITS
TS_SHIFT = SEQ_BITS + WK_BITS + DC_BITS
class Snowflake:
def __init__(self, worker_id=0, datacenter_id=0):
self.worker_id = worker_id
self.datacenter_id = datacenter_id
self.sequence = 0
self.last_ts = -1
def next_id(self):
ts = int(time.time() * 1000)
if ts == self.last_ts:
self.sequence = (self.sequence + 1) & MAX_SEQ
else:
self.sequence = 0
self.last_ts = ts
return (((ts - EPOCH) << TS_SHIFT)
| (self.datacenter_id << DC_SHIFT)
| (self.worker_id << WK_SHIFT)
| self.sequence)
if __name__ == "__main__":
sf = Snowflake(worker_id=1, datacenter_id=1)
N = 200_000
t0 = time.perf_counter()
for _ in range(N):
sf.next_id()
dt = time.perf_counter() - t0
print(f"{N:,} 个 ID 用时 {dt * 1000:.1f} ms -> {N / dt:,.0f} ID/秒")
print(f"相对 10,000 ID/秒 要求: {N / dt / 10000:.1f} 倍")本机(Apple M3 Pro,单线程)实测约 160 万~170 万 ID/秒,是「10,000 ID/秒」要求的 160 倍以上。
段长度该怎么调
第 2 组数据把每种分配的代价列清楚了。三条结论:
- 机器数比序列号更值钱:从 10 位机器号加到 12 位,机器总数从 4096 涨到 16384,代价是序列号从 12 位降到 10 位(单机上限 409 万 → 102 万 ID/秒)。要不要换,取决于你更需要「机器多」还是「单机并发高」。
- 时间戳位是唯一能延长寿命的:41 位 → 42 位,耗尽日期从 2080 年推到 2150 年。多花 1 位,换 70 年。
- 别把序列号开太大:机器号 8 位 + 序列号 15 位,单机上限 3276 万 ID/秒,代价是机器总数只有 1024。
原章说「根据使用场景调整各段大小」,但没给判断依据。上面的表就是依据——先算机器数、峰值 QPS、时间跨度三个数,再反推该给哪段多少位。
三、时钟回拨:真的会撞 ID
原章对时钟同步的处理只有一句:「使用 NTP 最小化时钟漂移」。但真正的问题不是漂移,是回拨——NTP 校时过程中时钟可能突然往回跳几十毫秒。
朴素实现(很多开源实现和教程里的写法)是这样的:
# -*- coding: utf-8 -*-
"""独立复现:朴素实现在时钟回拨后产出重复 ID。"""
EPOCH = 1288834974657
SEQ_BITS, WK_BITS, DC_BITS = 12, 5, 5
MAX_SEQ = (1 << SEQ_BITS) - 1
WK_SHIFT = SEQ_BITS
DC_SHIFT = SEQ_BITS + WK_BITS
TS_SHIFT = SEQ_BITS + WK_BITS + DC_BITS
def naive_next_id(ts, worker_id, datacenter_id, state):
"""有 bug 的常见实现:时钟回拨后序列号直接归零,不检查该时间戳是否用过。"""
if ts != state["last_ts"]:
state["seq"] = 0
else:
state["seq"] = (state["seq"] + 1) & MAX_SEQ
state["last_ts"] = ts
return (((ts - EPOCH) << TS_SHIFT)
| (datacenter_id << DC_SHIFT)
| (worker_id << WK_SHIFT)
| state["seq"])
base_ts = 1700000000000
state = {"last_ts": -1, "seq": 0}
first = [naive_next_id(base_ts, 1, 1, state) for _ in range(5)]
print(f"时刻 T 生成 5 个: 序列号 {[i & MAX_SEQ for i in first]}")
naive_next_id(base_ts - 500, 1, 1, state) # 时钟回拨 500 ms
again = [naive_next_id(base_ts, 1, 1, state) for _ in range(5)]
print(f"回拨后再到时刻 T: 序列号 {[i & MAX_SEQ for i in again]}")
dup = set(first) & set(again)
print(f"重复 ID 数 = {len(dup)} -> {'会撞!' if dup else '不会撞'}")时刻 T 生成 5 个: 序列号 [0, 1, 2, 3, 4]
回拨后再到时刻 T: 序列号 [0, 1, 2, 3, 4]
重复 ID 数 = 5 -> 会撞!它的判断是「时间戳变了就把序列号归零」——但没有检查这个时间戳是不是用过。时钟回拨到 T-500ms 再回到 T 时,T 这个时间戳已经在序列号 0~4 上用过一遍了,于是新的 ID 和旧的完全相同。
实测证实了:5 个 ID 全部重复。
标准解法就是开头那个实现里的保护:检测到 ts < last_ts 就抛错,宁可让这次调用失败,也不发一个可能重复的 ID。生产上通常再配一层兜底——等待时钟追上,或用「逻辑时钟」(记录偏移量,保证单调递增)。
唯一性是 ID 生成器唯一不可妥协的属性。 撞 ID 要么导致主键冲突、要么导致数据覆盖;顺序性差一点、可用性抖一下,都可以补救。所以时钟回拨时宁可失败也不能发重复 ID。
四、UUIDv7:原章的一条老缺点已经过期
原章列 UUID 的缺点是「超出 64 位要求」「不能按时间排序,且可能为非数值型」。第一条依然成立,第二条在 2024 年 5 月之后不成立了。
RFC 9562(2024 年 5 月发布,取代 RFC 4122)定义了 UUIDv7,其位布局是:
unix_ts_ms: 48 位 Unix 纪元毫秒时间戳(大端)
ver: 4 位 固定 0b0111
rand_a: 12 位 伪随机,或可选的单调计数器
var: 2 位 固定 0b10
rand_b: 62 位 伪随机,或可选的单调计数器前 48 位是 Unix 毫秒时间戳——所以 UUIDv7 天然按时间有序,可以直接当主键用,且不需要协调任何中心节点。它还多出 64 位给随机数/计数器,单机每秒能生成几百万个不重复的 UUID。
对比一下三条路的取舍:
| Snowflake | UUIDv7 | UUIDv4 | |
|---|---|---|---|
| 位宽 | 64 | 128 | 128 |
| 时间有序 | 是 | 是 | 否 |
| 需要机器号协调 | 是 | 否 | 否 |
| 单机吞吐上限 | 409.6 万/秒 | 数百万/秒 | 更慢 |
| 数据库主键友好度 | 好(8 字节) | 中(16 字节) | 差(随机插入) |
选型口径:
- 数据库主键、需要紧凑存储 → Snowflake,8 字节的整数比 16 字节的 UUID 省一半空间,而且整数主键在 B+ 树里顺序追加写入,不像 UUID 那样随机插入造成页分裂。
- 多机房、多语言、想要无协调的全局唯一 → UUIDv7。它 2024 年才标准化,很多 2020 年代的设计文章还在说「UUID 不可排序」,这个结论该更新了。
- 不要用 UUIDv4 当数据库主键——随机分布导致 B+ 树页分裂,写放大严重,这是它最实际的缺点(原章没提这一点)。
五、它不解决什么
- 它不保证跨库的全局唯一性。 Snowflake 的唯一性建立在「机器号不重复」这个前提上——两台机器配了同一个机器号,ID 就会撞。worker_id 的分配必须由中心服务或配置管理保证。
- 它不保证严格单调。 多机器情况下,A 机器的 ID 和 B 机器的 ID 谁大,取决于谁先生成。保证的是「时间戳有序」,不是「全局严格递增」。
- 它不解决 ID 的语义。 「用户 ID 能不能暴露创建时间」「订单 ID 里带用户 ID」是业务决策,技术方案不管。
FAQ(六、常见问题)
41 位时间戳用完了怎么办?
先说结论:2080 年前不用管。真到了那天,方案有几种:换纪元起点(但已发的 ID 还在用,不能改)、扩到 42 位(但会破坏已有的 64 位布局)、或者迁移到 UUIDv7(128 位,时间戳有 48 位,还能用 1 万多年)。这是 53 年后的事,现在做决策是浪费。
机器号(worker_id)应该怎么分配?
必须全局唯一。常见做法有两种:由 ZooKeeper/etcd 启动时注册分配(自动,但要处理注册失败和脑裂),或者由部署系统按静态配置注入(简单,但要保证配置不会错配)。最危险的做法是「随便填个机器 IP 的哈希」——哈希冲突的概率虽低,但一旦撞了就是数据损坏,且极难排查。
Snowflake 和自增主键到底差在哪?
自增主键(auto_increment)在单库场景永远是最优解:没有位运算、没有时钟依赖、存储紧凑、索引友好。Snowflake 存在的唯一理由是跨多个数据库节点发号。如果你的系统只有一个库,别用 Snowflake。
时钟回拨应该抛错还是等待?
默认抛错。 等待(spin 直到时钟追上)能提高可用性,但会把一个明确的错误变成一个不确定长度的阻塞——在时钟被大幅回拨时可能等很久,反而拖垮调用方。正确做法是抛错 + 上层重试,并配合逻辑时钟偏移量兜底,这样重试时生成的是新时间戳而不是旧时间戳。
延伸阅读
- 基础篇:跨机器协作:网络、副本与权限 — 发号服务为什么会成为单点,以及怎么用冗余化解
- 相关:封底估算:把系统设计的第一分钟花在算数量级上 — 「10,000 ID/秒」这类需求数字该怎么验算
- 标准:RFC 9562 — Universally Unique IDentifiers (UUIDs)(IETF,2024 年 5 月,取代 RFC 4122)
- 原文:System Design Interview — An Insider’s Guide 第 7 章(Alex Xu 著,商业出版物;本文的中文笔记来自社区翻译仓库,未获原作者授权转载)
出处与许可
- 原始出处:Alex Xu《System Design Interview — An Insider’s Guide》(Vol 1 & 2, 2nd Ed.),第 7 章「Design a Unique ID Generator in Distributed Systems」。原书为商业出版物,版权归作者所有。
- 本文所据的中文笔记:
lukeTheNeuromancer/system-design-notes-zh(社区翻译版)与英文原笔记liquidslr/system-design-notes。这两个仓库均未附带任何 LICENSE 文件(GitHub API 返回license: null;对 main/master 分支逐一请求 LICENSE / LICENSE.md / LICENSE.txt / COPYING 均为 404),即未获任何转载或改编授权。 - 因此本文的处理:仅做方法层面的译述与讨论,不转载、不改编原书或两个笔记仓库的正文;引用限于概念与位布局的口径说明,并逐处标明来源。全部技术内容以本文自己的实测与一手标准文档为依据。
- 本文自有的增量(占正文主体):① 可运行的 Snowflake 实现与六组实测数据(时间戳耗尽日期、段长度调优表、需求反推、位布局解码、时钟回拨重复 ID、吞吐基准);② 对原章未量化断言的补齐——「10,000 ID/秒」在真实分布式规模下每台仅需 9.77 QPS、序列号 0 位即可;③ 时钟回拨导致重复 ID 的实测复现(朴素实现产出 5 个重复 ID),及标准解法的对比;④ RFC 9562 / UUIDv7 这一原章出版后(2024 年 5 月)才出现的选项,并指出「UUID 不能排序」这条缺点已过期;⑤ 机器号分配、ID 语义边界等原章未覆盖的工程约束。
- 未经原作者授权。如需正式引用原书内容,请购买原书并遵守其版权条款。