跳到主要内容
目录

唯一 ID 生成器:把 Snowflake 的位分配算到底

设计分布式系统时,「这个 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。

对比一下三条路的取舍:

SnowflakeUUIDv7UUIDv4
位宽64128128
时间有序是是否
需要机器号协调是否否
单机吞吐上限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 直到时钟追上)能提高可用性,但会把一个明确的错误变成一个不确定长度的阻塞——在时钟被大幅回拨时可能等很久,反而拖垮调用方。正确做法是抛错 + 上层重试,并配合逻辑时钟偏移量兜底,这样重试时生成的是新时间戳而不是旧时间戳。

延伸阅读

出处与许可

  • 原始出处: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 语义边界等原章未覆盖的工程约束。
  • 未经原作者授权。如需正式引用原书内容,请购买原书并遵守其版权条款。
赞赏

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

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

    微信支付

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

    支付宝

金额随意,感谢支持

赞赏

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

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

    微信支付

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

    支付宝

金额随意,感谢支持