一次秒杀活动开始前 3 分钟,运维把机器时间往前校了一下,结果时钟往回退了 5ms。活动开始后,订单服务在同一个毫秒里连续生成编号,序列号刚好用满又回到 0,时间戳却重复了上一次的值,于是 11 个 ID 里出现了 1 个重复。插入撞主键,三笔下单直接返回 500。
这次故障里最反直觉的是「只回拨了 5ms」。5ms 在人类看来几乎不存在,可对一台每秒生成几十万个 ID 的机器来说,5ms 足够让同一时间戳、同一序列号组合再出现一次。ID 生成器对时间的要求,比大多数业务都苛刻。
这篇把三种主流方案摆开:数据库自增、UUID、雪花算法。重点不是推荐哪个,而是说清楚每个方案在什么条件下会坏,坏了会以什么形式表现出来。
自增 ID:简单,但把并发押在一台机器上
先看一张对照表。ID 出问题时,现象往往不在 ID 服务本身,而是在下单、插入、分页这些下游动作上。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 插入偶发撞主键、返回 500 | 时钟回拨后同一毫秒的序列号被复用 | 查生成器时钟偏移和重复 ID 样本 |
| 分库后两个订单号完全相同 | 每个库各自自增,没有全局号段 | 查各库自增起始值与步长 |
| 写入越跑越慢,索引持续膨胀 | 随机 UUID 做主键,插入位置分散导致页分裂 | 查主键类型、索引大小、页分裂率 |
| 按 ID 分页漏数据或重复 | 雪花只是趋势递增,跨机器不保证严格有序 | 改用独立序列号或稳定游标字段 |
| 容器重建后偶发重复编号 | 机器号被复用,旧实例仍在发号 | 查机器号注册表与回收租约 |
| 高峰时发号明显变慢 | 单机每毫秒 4096 个序列号被打满 | 算峰值 QPS,拆多实例并分配独立机器号 |
| 校时后生成器拒绝启动 | 回拨幅度超过阈值,触发了保护性失败 | 查 NTP 校时记录与回拨阈值 |
| 订单号连续,外部能推算单量 | 自增编号暴露了业务规模 | 评估是否需要号段加扰动或外部展示编号 |
单机数据库的自增主键是最省事的方案。插入时数据库自己加一,天然唯一,天然递增,还短。单库单表、数据量不大的系统,没必要舍近求远。
问题出在「要扩容」的那一刻。分库分表之后,每个库各自自增,就会出现两个库都生成 1、2、3 的情况,全局重复。常见的补法是给每个库设不同的起始值和步长,比如三个库分别从 1、2、3 开始,步长 3。这样能保证全局唯一,但扩容时步长要改,历史数据又得重排,运维成本不低。
还有一种做法是抽一个独立的号段服务,一次从数据库取一段号(比如 1000 个)缓存在内存里,用完再取。它把数据库的写压力降下来了,可号段服务本身又成了新的单点。它挂了,所有依赖它的服务都发不出号。
自增 ID 还有个隐性代价:它暴露了业务量。用户看到订单号是 10001,就知道平台大概只卖了一万单;竞品看到编号连续,还能推算你的增长速度。对很多业务来说,这不是技术问题,是商业信息泄露。
号段服务要做得稳,通常会配双 buffer:当前号段用到一半时,后台异步去取下一段,避免用满那一刻同步等待。这样做的代价是号段可能浪费一部分,服务重启后没用完的号就丢了,但换来的是发号几乎不阻塞。要接受「ID 有空洞」这个事实,因为自增 ID 一旦要求严格连续,就又回到了单点。
UUID:唯一性够,但把索引写胖了
UUID 是一串随机生成的 128 位标识,标准写法是 32 个十六进制字符加 4 个连字符。它最大的优点是去中心化:任何一台机器都能独立生成,不用问任何人,理论上不会重复。多机房、多实例、离线设备,都能用。
但把它当数据库主键,代价很快显现。第一,它无序。随机 UUID 插入 B 树索引时,几乎每次都要落在中间某个位置,导致页分裂、缓存命中率下降,写入越往后越慢。第二,它长。36 个字符存在索引里,比 8 字节的整数大四五倍,索引体积和内存占用跟着涨。第三,它不可读,排查问题时没法从 ID 看出时间、来源、顺序。
有些团队用 UUID v4 做主键,再额外加一个自增列做聚簇索引,等于用两个 ID 换一个折中。也有人用「有序 UUID」,把时间前缀塞进去,让新 ID 大致排在后面,缓解页分裂。这些做法都说明一件事:UUID 解决的是唯一性,不是排序和索引友好。
UUID 本身也分版本。v1 把时间和网卡地址拼进去,能看出生成时间,但会暴露机器信息;v4 纯随机,最常用;v7 把毫秒时间放在最前面,兼顾唯一和趋势递增,近几年被很多新系统采用。选版本时要看清它把什么放进了 ID,因为这决定了它会不会泄露信息、能不能排序。
还有一类叫 ULID 的方案,用时间前缀加随机后缀,长度比 UUID 短,字符集也更适合排序。它和 UUID v7 的思路接近,都是「想同时拿到唯一和有序」。这类方案适合新系统,但要注意生态支持,别为了短几字节引入一套没人维护的库。
自增适合什么
单库、数据量可控、需要短 ID、不介意暴露量级。扩容前就要想好分片后的号段方案,别等到数据涨上来才改主键。
UUID 适合什么
离线生成、跨系统合并、不需要按 ID 排序、能接受较长字符串。用作业务主键时,最好别再让它承担聚簇索引的顺序。
雪花算法:把时间、机器、序列拼进一个整数
雪花算法的思路是把一个 64 位整数切成几段,每段负责一件事。最高位不用,接着一段是时间戳,一段是机器编号,最后一段是同一毫秒内的序列号。拼起来既唯一,又大致按时间递增。
为什么叫「趋势递增」而不是「严格递增」。因为同一毫秒内,序列号是递增的;跨毫秒时,时间戳变大,整体也变大。但如果机器时钟回拨,或者多台机器的时钟略有偏差,不同机器产生的 ID 就不保证严格有序。它只保证「大体上越来越大」,这对数据库索引已经足够,对「必须严格按顺序」的场景则不够。
机器号的分配是这套方案里最容易被低估的部分。10 位机器号意味着最多 1024 个生成器,超过就得复用。复用之前必须确认旧机器不会再生成 ID,否则两个生成器用同一个机器号、同一毫秒、同一个序列号,就会撞。容器化环境里,Pod 重建后拿到同一个机器号是很常见的事。
41 位时间戳的容量可以自己算:2 的 41 次方约等于 2.2 万亿毫秒,换算成年大约 69 年。听起来很久,但如果起点设得早、系统又活得久,总有一天会用完。到期前要么换起点并迁移历史 ID,要么加长时间戳位数,这都不是临时能做的决定,设计时就要把年限写进文档。
跨机房部署时,机器号最好拆成「机房号加机器号」两段。否则两个机房各自从 0 开始编号,很容易撞号。拆分后每个机房有自己的号段,扩容时也只在本机房内分配,冲突面小很多。代价是单机房能用的机器数变少,要提前估算。
// 雪花算法拼装(伪代码)
id = (timestamp_ms - epoch) << 22
| (machine_id & 0x3FF) << 12
| (sequence & 0xFFF)
// 同一毫秒内 sequence 自增;到 4096 就等到下一毫秒
fn next_id():
now = current_millis()
if now < last_ts: handle_clock_backwards(now)
if now == last_ts:
sequence = (sequence + 1) & 0xFFF
if sequence == 0: now = wait_next_millis(last_ts)
else:
sequence = 0
last_ts = now
return compose(now, machine_id, sequence)
这段伪代码里最关键的一行是「now 小于 last_ts」时的处理。正常路径都好写,真正决定这套方案能不能上生产的,是时钟往回走的时候你做什么。
还有一个常被忽略的细节:同一毫秒内序列号是从 0 开始还是从随机数开始。从 0 开始简单,但意味着每毫秒的号段固定可预测;从随机数开始能减少碰撞面,代价是单毫秒容量变小。多数实现从 0 开始,因为可预测本身不是问题,重复才是。
时钟回拨:5ms 就能制造重复
时钟回拨指机器时间往回跳。原因很多:NTP 校正、虚拟机迁移、手动改时间、宿主机休眠后恢复。对普通业务,回拨几百毫秒最多让日志时间乱一点;对雪花算法,回拨意味着「已经用过的时间戳可能再用一次」。
5000 个 ID 去重后 5000 个,单调递增=true
带检查: 生成器抛错「时钟回拨 5ms」,宁可短暂不可用,也不发重复 ID
不做检查: 共生成 11 个 ID,去重后 10 个,重复 1 个
重复样本: 2000-0-naive 2000-1-naive 2000-2-naive 2000-0-naive
第三组数字是「不做检查」的后果:11 次生成里有 10 个唯一、1 个重复。看重复样本更清楚,前三步序列号从 0 走到 2,时间戳都是 2000;时钟回拨后又回到时间戳 2000、序列号 0,于是第一条 ID 被原样生成了一遍。
第二组是「带检查」的结果:生成器发现时钟回拨了 5ms,直接抛错。代价是这 5ms 内发不出新 ID,业务可能短暂不可用;收益是绝不放出一个重复编号。这就是这套方案的核心取舍,宁可短暂不可用,也不发重复 ID。
还有几种兜底策略。一是等,让时钟自己追上 last_ts 再继续,适合回拨很小、能接受短暂阻塞的场景。二是换机器号,回拨后启用一个备用编号,绕开重复组合,但要保证备用号没有被用过。三是记录回拨幅度并告警,超过阈值就拒绝启动。无论选哪种,都不能「假装没发生」继续发号。
检测回拨本身很简单:每次生成前拿当前毫秒和上一次记录的时间戳比,小了就是回拨。难的是「漂移」和「回拨」的区别。漂移是钟慢慢走偏,每次只差几微秒,不会让时间戳倒退;回拨是时间突然往回跳,会直接制造重复。监控上要分别对待:漂移看长期偏移量,回拨看单次跳变量。
不要指望「关掉自动校时」就能躲开回拨。关掉之后,钟会越走越偏,跨机器比较照样出错,而且漂移是累积的,跑了几个月可能差出好几秒。正确做法不是不校时,而是校时之后让生成器知道「刚才发生了什么」,并对回拨做出明确反应。
参数怎么定:起点、机器号、等待策略
时间戳的起点要固定,不能每次重启都换。起点决定了这套 ID 能用多久,41 位从 2020 年起算大约到 2089 年,够用;但如果起点设成当前时间,升级时就不好迁移。起点一旦上线,就当常量对待。
机器号要有分配和回收机制。小规模可以写在配置文件里,人工保证不重复;规模大了要有一份注册表,启动时申请、下线时释放,并记录「最后一次发号时间」。回收后再次分配前,至少等过一段时间,确保旧实例不会再产生同一毫秒的号。
序列号用满时的等待策略也要定。直接自旋等待下一毫秒,实现简单,但高并发时会把 CPU 打高;更好的做法是短暂让出,或者用「借下一秒」的预支方案,但要同时记录预支了多少,避免长期偏移。无论哪种,等待时间都要有上限,超过就报错,而不是无限等。
机器号注册表不需要很复杂,一张带租约的表就够:申请时写入编号、实例标识和过期时间,运行期间定期续租,下线或过期后允许别人复用。关键是复用前查一下「这个编号最后一次发号的时间」,确保已经过了可能撞号的窗口,而不是简单地删掉记录就发出去。
# 生成器配置(示意)
snowflake:
epoch: 2020-01-01T00:00:00Z # 固定起点,上线后不改
machine_id: 17 # 从注册表申请,保证唯一
sequence_bits: 12 # 每毫秒 4096 个
max_backward_ms: 5 # 回拨不超过 5ms 可等待
on_backward_exceed: fail # 超过就拒绝发号并告警
wait_next_ms_timeout: 2ms # 等下一毫秒的上限
# 时钟回拨处理(伪代码)
fn handle_clock_backwards(now):
delta = last_ts - now
if delta <= max_backward_ms:
sleep(delta); return current_millis()
else:
alarm("clock moved backwards"); throw ClockBackwards
监控上要专门盯两件事:时钟偏移和重复率。偏移可以用一个独立的校时服务对比,超过几十毫秒就告警;重复率则在写入侧靠主键冲突暴露,冲突数突然上升,第一反应就该查生成器时钟,而不是查业务代码。
容量也要算清楚。12 位序列号意味着单机每毫秒最多 4096 个,换算成每秒约 400 万个。这个上限对绝大多数业务绰绰有余,但如果你把生成器放在单实例、又赶上大促瞬间,还是可能把序列号打满,退化成「每秒只能发 400 万」。这时候要做的不是加大序列号位数,而是拆多实例、给每个实例独立机器号。
边界与代价
没有一种 ID 方案对所有场景都最优。单库小系统用自增最省事;离线、跨组织合并用 UUID 最稳;高并发、要短、要趋势递增,才轮到雪花。先看约束再选型,别因为「大厂都用雪花」就给自己上一个需要维护机器号和时钟的系统。
雪花把复杂度从数据库挪到了运维。机器号要管、时钟要盯、回拨要兜、序列号要等。这些都不是代码写完就结束的事,而是长期运行时要持续处理的事。团队没有相应的运维能力,雪花反而比自增更容易出事。
趋势递增不等于严格递增。依赖「ID 一定比前一个大」来做业务排序、做增量同步、做游标分页,都会在跨机器、时钟偏差、回拨时翻车。这类场景应该用独立的序列号或版本号,而不是把业务顺序寄托在主键上。
UUID 的唯一性也有前提。v4 依赖随机数质量,随机源弱的设备上重复概率会上升;跨系统合并时,还要确认两边真的用了同一套版本和格式。把 UUID 当成「绝对不重复」的免死金牌,是另一种偷懒。
换方案比选方案更难。ID 一旦写进数据库、发出去给用户、被下游系统引用,再换格式就要迁移历史数据、兼容旧编号、处理两套 ID 并存。很多团队不是选错了,而是选完之后没留退路。上线前就该想清楚:这套 ID 将来能不能平滑扩容、能不能换生成器、旧号还能不能继续被识别。
当天可以自验的五件事
- 找出系统里所有生成 ID 的地方,标注用的是自增、UUID 还是雪花,以及各自依赖什么外部条件。
- 把本机时间往回改 5ms,观察雪花生成器是抛错、等待还是继续发号,记录实际行为。
- 统计订单表主键的类型和长度,估算索引占用的空间,判断 UUID 是否正在把索引写胖。
- 检查机器号的分配方式,确认容器重建或实例迁移后不会拿到一个已被占用的编号。
- 用同一批 ID 连续插入两次,确认数据库或写入层是否真的能拦住重复,而不是靠「应该不会重复」。
ID 解决了「谁是谁」的问题,接下来是「谁有资格改」。多台机器同时想改同一份数据时,需要一个机制保证同一时刻只有一个人动手,这就是分布式锁。下一篇《分布式锁:Redis 锁和 etcd 租约差在哪》会从一次锁过期后双方都以为自己持锁的故障讲起。