雪花算法生成重复订单号 时钟回拨4步防住
凌晨两点,订单表唯一索引突然报冲突。查出来两条订单的
order_no一模一样,都是一串 18 位数字。代码里用了雪花算法,加锁也加了,机器也是分开部署的——照样撞。真正的原因有两个:两台机器的 workerId 手工配成了同一个值,其中一台的时钟还被 NTP 往回拨了 800 毫秒。这篇把 64 位怎么排、回拨为什么躲不掉、workerId 该怎么分配讲清楚,最后给两套能直接跑起来的发号代码。
一、这个问题到底是什么
雪花算法(Snowflake)干的事很简单:把一个 64 位整数切成几段,分别塞进时间戳、机器编号和毫秒内序号,拼成一个 long。时间在走、机器不同、序号递增,拼出来的数字就不会重复。
听起来很稳,用起来全是坑。
第一个误区:加了 synchronized 就安全。
synchronized 只能保证同一个 JVM 里两个线程不会同时拿到同一个序号。你的服务部署了 8 个 Pod,就有 8 个互不相干的锁。8 个 JVM 各自从 0 开始数序号,只要时间戳和机器号一样,撞号是必然的。
第二个误区:机器不一样,ID 就不会一样。
机器号(workerId)是自己配的,不是自己算出来的。配置文件里写 worker-id: 1,然后拿这份配置打了个镜像,起了 4 个副本——4 个副本的 workerId 全是 1。这就是那次事故的直接原因:运维图省事,用同一份 ConfigMap 滚了全部实例。
第三个误区:UUID 能替代一切。
UUID 确实不会重复。但它是 128 位、完全无序的。MySQL 的 InnoDB 按主键建聚簇索引,主键无序意味着每次插入都可能落在 B+ 树的中间页,引发页分裂和随机磁盘写。数据量上到几千万,插入速度会掉一个数量级,索引体积也大一圈。
第四个误区:时钟只会往前走。
系统时间是会往后退的。NTP 校时、虚拟机迁移、容器被调度到另一台宿主机、有人手工改时间,都会让 System.currentTimeMillis() 返回一个比上次更小的值。雪花算法一旦发现“现在比上一毫秒还早”,如果代码没做处理,它就会重新从 0 开始发号——同一毫秒、同一机器、同一序号,又是一个重复的 long。
一个能用的分布式 ID,要同时满足四条:
| 指标 | 具体要求 | 为什么 |
|---|---|---|
| 全局唯一 | 多机房、多实例都不能撞 | 撞了就是资损或者主键冲突 |
| 趋势递增 | 后生成的 ID 更大 | InnoDB 顺序写,减少页分裂 |
| 高性能 | 单机能到十万级每秒 | 发号不能成为下单链路的瓶颈 |
| 不暴露业务量 | 外人看不出今天下了多少单 | 竞对天天盯着你的订单号看 |
雪花算法能同时满足前三条,第四条靠“起始时间点随机”勉强能做到。它真正的软肋是依赖本地时钟——时钟一乱,全盘皆输。
二、底层原理到底怎么回事
64 位是怎么切的
一个 long 有 64 位,最高位是符号位,Java 里 long 是有符号的,最高位必须留 0,不然拼出来的就是负数。剩下 63 位这样分:
| 段 | 位数 | 作用 | 说明 |
|---|---|---|---|
| 符号位 | 1 | 固定 0 | 保证是正数 |
| 时间戳 | 41 | 当前毫秒 - 起始毫秒 | 41 位能撑约 69 年 |
| 数据中心 | 5 | 机房编号 | 最多 32 个机房 |
| 机器号 | 5 | 实例编号 | 每个机房最多 32 台 |
| 序列号 | 12 | 同一毫秒内的序号 | 每毫秒最多 4096 个 |
拼装就是移位加或运算:
long id = ((timestamp - EPOCH) << 22)
| (dataCenterId << 17)
| (workerId << 12)
| sequence;
时间戳左移 22 位(5+5+12),数据中心左移 17 位,机器号左移 12 位,序列号占最低 12 位。
这里有个容易被忽略的细节:起始时间(EPOCH)选得越晚,能用的年限越短。选 2025-01-01 做起点,41 位能用到 2094 年;如果选 1970 年,现在就已经用掉一半了。别抄别人的 1288834974657(Twitter 的起点),自己定一个上线日期就行。
时钟为什么会往回拨
系统时钟不是一个匀速走的表。Linux 通常跑着 NTP 或者 chrony,定期和上游时间服务器对表。对表有两种方式:
- slew(微调):把时钟走快或走慢一点点,慢慢追上,不会倒退。
- step(步进):直接把时钟设成正确值,可能一下子往前跳,也可能往后跳。
chrony 默认在偏差超过阈值(一般 1 秒左右)时用 step,偏差小的时候用 slew。机器刚启动、长时间休眠后唤醒、虚拟机被挂起再恢复,偏差很容易超过 1 秒,于是时钟就会“啪”地往回跳一下。
虚拟化环境更麻烦。宿主机上的时间同步会传导给所有虚拟机;容器共享宿主内核的时钟;K8s 把 Pod 调度到另一台节点,那台节点的时间如果慢了几百毫秒,你的进程一启动就“回到过去”了。
真实事故里那 800 毫秒就是这么来的:一台物理机换了主板电池,重启后时间慢了 0.8 秒,chrony 启动时做了一次 step 校正。
回拨的时候到底会发生什么
假设上一笔发号是 T=1000ms, worker=1, seq=5。下一秒时钟退回 T=999ms。代码里如果只判断“当前时间大于上次时间就递增序列,否则序列清零”,那么 T=999 会重新从 seq=0 开始,连发 4096 个号。这其中如果之前已经发过 T=999, worker=1, seq=0,就撞了。
注意撞号的条件很苛刻:同一毫秒 + 同一 workerId + 同一序列。三者全中才会重复。所以这类 bug 平时测不出来,只在时钟跳变的那一瞬间出现,而且往往是一批订单同时出错。
三种应对策略,代价不一样
| 策略 | 做法 | 优点 | 代价 |
|---|---|---|---|
| 等待 | 发现回拨就 sleep 到上次时间 | 简单,不丢号 | 回拨多久就卡多久,800ms 就是 800ms 的接口超时 |
| 直接抛异常 | 发现回拨立刻失败 | 绝不发重号 | 业务方要处理异常,重试还可能继续失败 |
| 逻辑时钟 | 把上次时间戳当“现在”,序列继续加 | 不阻塞、不失败 | 回拨期间时间戳是假的,ID 会略微超前 |
生产上我推荐组合:回拨幅度小(比如 5ms 内)就自旋等待,幅度大就直接抛异常让上游降级。逻辑时钟适合对可用性要求极高、能接受 ID 时间戳轻微不准的场景,但它有个隐患——如果多台机器都各自“借用未来”,恢复后可能出现时间戳交叉,虽然不会撞号,但严格递增的性质会变弱。
workerId 才是最容易出事的地方
时钟回拨属于偶发,workerId 冲突属于必然。
手工在配置文件里写死 workerId,只要出现下面任何一种情况就会重复:
- 同一个镜像起了多个副本
- 扩容时复制了一份配置
- 换机器但没改配置
- 灰度环境和生产环境用了同一份配置
正确的做法是让程序自己抢一个唯一编号,并且带续租。常见方案:
- 数据库自增表:启动时
INSERT一条记录拿到自增 ID,按id % 32取模当 workerId,同时写心跳时间。 - Redis:
INCR一个 key,或者用SETNX抢槽位,配合过期时间做租约。 - ZooKeeper/etcd:创建临时顺序节点,连接断开自动释放。
- K8s StatefulSet:Pod 名自带序号(
app-0、app-1),直接解析出来当 workerId,这是最省事的。
方案 4 在 K8s 环境里几乎没有成本,但它只保证 Pod 序号唯一,不保证跨环境唯一。多集群部署时还是得加个机房前缀。
号段模式为什么不怕时钟
号段模式(Segment)不依赖本地时钟,它改成“批发”:一次从数据库里申请 1000 个号,本地慢慢发,发完了再申请下一批。
UPDATE id_segment SET max_id = max_id + step WHERE biz_tag = 'order';
SELECT max_id FROM id_segment WHERE biz_tag = 'order';
两条语句在同一个事务里执行,max_id 加完之后读出来,就得到了这一段的上界,下界是上界减 step 加 1。数据库的行锁保证了并发安全,两个实例不可能拿到同一段。
它的问题是每次取号要访问数据库。解决方式是双 buffer:当前号段还剩 20% 的时候,就提前把下一段取回来存着,等当前段用完直接切换。这样取号的 DB 访问被藏在业务请求的间隙里,用户感知不到卡顿。
代价是:服务重启会浪费掉当前号段剩余的号(号码不连续),以及对数据库有依赖——数据库挂了,号段用完就发不出号。
三、实战:手把手写代码
下面这套工程包含两种发号方式:雪花算法(带时钟回拨保护)和号段模式(双 buffer)。两个都能独立使用,也可以像美团 Leaf 那样组合起来——用号段模式发 workerId,用雪花发业务 ID。
3.1 完整 pom.xml
Spring Boot 4 的依赖管理仍然由 parent 统管,但这里每个依赖都写全了版本号,方便你直接核对。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>4.1.2</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>id-generator</artifactId>
<version>1.0.0</version>
<name>id-generator</name>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<version>26.10.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>4.1.2</version>
</plugin>
</plugins>
</build>
</project>
3.2 完整 application.yml
workerId 不放在配置里,交给下一节的 WorkerIdAllocator 从主机名解析。配置里只留机房编号和起始时间,这两个值所有实例都一样,改起来也安全。
server:
port: 8080
spring:
application:
name: id-generator
datasource:
url: jdbc:mysql://127.0.0.1:3306/id_demo?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username: root
password: root123
driver-class-name: com.mysql.cj.jdbc.Driver
id:
snowflake:
data-center-id: 1
epoch: 1735689600000
segment:
biz-tag: order
step: 1000
3.3 workerId 自动分配
这个类解决“多个实例抢到同一个编号”的问题。K8s 的 StatefulSet 会给 Pod 起带序号的名字(id-gen-0、id-gen-1),直接把序号拿来做 workerId 最省事。名字里没有序号时,退化成按 IP 末位取模,同时打日志提醒运维。
package com.example.idgen.id;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.net.InetAddress;
import java.net.UnknownHostException;
@Component
public class WorkerIdAllocator {
private static final Logger log = LoggerFactory.getLogger(WorkerIdAllocator.class);
private static final long WORKER_ID_COUNT = 32;
private final long workerId;
public WorkerIdAllocator(@Value("${HOSTNAME:localhost}") String hostname) {
this.workerId = parseFromHostname(hostname);
log.info("当前实例分配的 workerId = {}, 主机名 = {}", workerId, hostname);
}
private long parseFromHostname(String hostname) {
int dash = hostname.lastIndexOf('-');
if (dash >= 0) {
try {
long ordinal = Long.parseLong(hostname.substring(dash + 1));
return ordinal % WORKER_ID_COUNT;
} catch (NumberFormatException ignored) {
// 主机名带横线但不是序号结尾,走 IP 兜底
}
}
return fallbackByIp(hostname);
}
private long fallbackByIp(String hostname) {
try {
byte[] address = InetAddress.getLocalHost().getAddress();
long id = Math.floorMod(address[address.length - 1], WORKER_ID_COUNT);
log.warn("主机名 {} 解析不出序号,按 IP 末位兜底为 {}, 请检查部署方式", hostname, id);
return id;
} catch (UnknownHostException e) {
throw new IllegalStateException("无法确定 workerId,请检查主机名和网络配置", e);
}
}
public long workerId() {
return workerId;
}
}
IP 兜底只能应急。10.0.0.33 和 10.0.0.1 取模之后都是 1,一旦出现这种情况照样会撞。日志里的 WARN 就是留给运维抓的,别把它当噪音过滤掉。
3.4 雪花算法完整实现
这个类做了四件事:回拨小幅等待、回拨大幅抛异常、同一毫秒内序列自增、序列打满时自旋到下一毫秒。
package com.example.idgen.id;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* 雪花算法发号器。
* 结构:1 位符号 + 41 位时间戳 + 5 位机房 + 5 位机器 + 12 位序列。
*/
@Component
public class SnowflakeIdGenerator {
/** 起始时间戳,2025-01-01 00:00:00 UTC */
private final long epoch;
private final long dataCenterId;
private final long workerId;
private static final long WORKER_ID_BITS = 5L;
private static final long DATA_CENTER_ID_BITS = 5L;
private static final long SEQUENCE_BITS = 12L;
private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS); // 31
private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS); // 31
private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS); // 4095
private static final long WORKER_ID_SHIFT = SEQUENCE_BITS; // 12
private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS; // 17
private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS; // 22
/** 回拨在这个范围内就自旋等待,超过就抛异常 */
private static final long MAX_WAIT_ON_ROLLBACK_MS = 5L;
private long sequence = 0L;
private long lastTimestamp = -1L;
public SnowflakeIdGenerator(
WorkerIdAllocator workerIdAllocator,
@Value("${id.snowflake.data-center-id}") long dataCenterId,
@Value("${id.snowflake.epoch}") long epoch) {
long allocatedWorkerId = workerIdAllocator.workerId();
if (allocatedWorkerId < 0 || allocatedWorkerId > MAX_WORKER_ID) {
throw new IllegalArgumentException("workerId 必须在 0 到 " + MAX_WORKER_ID + " 之间");
}
if (dataCenterId < 0 || dataCenterId > MAX_DATA_CENTER_ID) {
throw new IllegalArgumentException("dataCenterId 必须在 0 到 " + MAX_DATA_CENTER_ID + " 之间");
}
this.workerId = allocatedWorkerId;
this.dataCenterId = dataCenterId;
this.epoch = epoch;
}
public synchronized long nextId() {
long timestamp = currentTime();
if (timestamp < lastTimestamp) {
long offset = lastTimestamp - timestamp;
if (offset <= MAX_WAIT_ON_ROLLBACK_MS) {
// 回拨很小,等到时间追上再发号,最多等 5 毫秒
timestamp = waitUntil(lastTimestamp);
} else {
// 回拨幅度大,拒绝发号,让上游感知并降级
throw new IllegalStateException(
"系统时钟回拨 " + offset + " 毫秒,拒绝发号,请检查 NTP 配置");
}
}
if (timestamp == lastTimestamp) {
sequence = (sequence + 1) & SEQUENCE_MASK;
if (sequence == 0) {
// 这一毫秒的 4096 个号用完了,自旋到下一毫秒
timestamp = waitUntil(lastTimestamp + 1);
}
} else {
sequence = 0L;
}
lastTimestamp = timestamp;
return ((timestamp - epoch) << TIMESTAMP_SHIFT)
| (dataCenterId << DATA_CENTER_ID_SHIFT)
| (workerId << WORKER_ID_SHIFT)
| sequence;
}
private long currentTime() {
return System.currentTimeMillis();
}
private long waitUntil(long target) {
long now = currentTime();
while (now < target) {
Thread.onSpinWait();
now = currentTime();
}
return now;
}
}
几个关键点值得单独说:
TIMESTAMP_SHIFT 是 22,不是 12。它必须等于另外三段位数之和,写错了拼出来的 ID 会互相覆盖。这里的 22 = 12(序列)+ 5(机器)+ 5(机房)。
waitUntil 用 Thread.onSpinWait() 而不是 Thread.sleep(1)。sleep 的最小粒度通常是 1 毫秒,回拨 5 毫秒就得睡 5 次,而且每睡一次都可能多睡 20%。自旋在这几毫秒的量级里更精确。
nextId() 是 synchronized 的。单机发号的瓶颈就在这把锁上,实测单核每秒能发几百万个号,远超过业务需求,没必要为了那点吞吐换成 CAS。
3.5 启动类和 Controller
package com.example.idgen;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class IdGeneratorApplication {
public static void main(String[] args) {
SpringApplication.run(IdGeneratorApplication.class, args);
}
}
package com.example.idgen.web;
import com.example.idgen.id.SegmentIdGenerator;
import com.example.idgen.id.SnowflakeIdGenerator;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping("/id")
public class IdController {
private final SnowflakeIdGenerator snowflakeIdGenerator;
private final SegmentIdGenerator segmentIdGenerator;
public IdController(SnowflakeIdGenerator snowflakeIdGenerator,
SegmentIdGenerator segmentIdGenerator) {
this.snowflakeIdGenerator = snowflakeIdGenerator;
this.segmentIdGenerator = segmentIdGenerator;
}
@GetMapping("/snowflake")
public long snowflake() {
return snowflakeIdGenerator.nextId();
}
@GetMapping("/segment")
public long segment() {
return segmentIdGenerator.nextId();
}
@GetMapping("/batch")
public List<Long> batch(@RequestParam(defaultValue = "10") int size) {
List<Long> ids = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
ids.add(snowflakeIdGenerator.nextId());
}
return ids;
}
}
注意 /snowflake 和 /segment 直接返回 long。浏览器里拿到的会是一长串数字,JavaScript 的 Number 只有 53 位精度,超过 9007199254740992 就会被截断。前端调用时务必让后端转成字符串返回,或者前端用 BigInt 接收。这个坑后面还会展开。
3.6 号段模式完整实现
先建表。biz_tag 让不同的业务共用一个表但各发各的号,step 允许不同业务用不同的批发粒度。
CREATE DATABASE IF NOT EXISTS id_demo DEFAULT CHARACTER SET utf8mb4;
USE id_demo;
CREATE TABLE IF NOT EXISTS id_segment (
biz_tag VARCHAR(64) NOT NULL COMMENT '业务标识',
max_id BIGINT NOT NULL COMMENT '当前已分配到的最大 ID',
step INT NOT NULL COMMENT '每次批发的数量',
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (biz_tag)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT ='号段表';
INSERT INTO id_segment (biz_tag, max_id, step)
VALUES ('order', 1, 1000)
ON DUPLICATE KEY UPDATE max_id = max_id;
发号器本体:
package com.example.idgen.id;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.support.TransactionTemplate;
@Component
public class SegmentIdGenerator {
private final JdbcTemplate jdbcTemplate;
private final TransactionTemplate transactionTemplate;
private final String bizTag;
private final int step;
private volatile Segment current;
private volatile Segment next;
public SegmentIdGenerator(JdbcTemplate jdbcTemplate,
TransactionTemplate transactionTemplate,
@Value("${id.segment.biz-tag}") String bizTag,
@Value("${id.segment.step}") int step) {
this.jdbcTemplate = jdbcTemplate;
this.transactionTemplate = transactionTemplate;
this.bizTag = bizTag;
this.step = step;
}
public synchronized long nextId() {
if (current == null || current.isExhausted()) {
if (next != null) {
current = next;
next = null;
} else {
current = fetchSegment();
}
}
long id = current.next();
// 剩余不到 20% 就预取下一段,把 DB 往返藏在业务间隙里
if (next == null && current.remaining() <= step / 5) {
next = fetchSegment();
}
return id;
}
private Segment fetchSegment() {
Long newMaxId = transactionTemplate.execute(status -> {
jdbcTemplate.update(
"UPDATE id_segment SET max_id = max_id + step WHERE biz_tag = ?", bizTag);
return jdbcTemplate.queryForObject(
"SELECT max_id FROM id_segment WHERE biz_tag = ?", Long.class, bizTag);
});
if (newMaxId == null) {
throw new IllegalStateException("号段表里没有 biz_tag = " + bizTag + " 的记录");
}
long maxId = newMaxId;
return new Segment(maxId - step + 1, maxId);
}
/** 一段连续的号码,从 min 发到 max */
private static final class Segment {
private final long max;
private long cursor;
private Segment(long min, long max) {
this.max = max;
this.cursor = min;
}
private long next() {
return cursor++;
}
private boolean isExhausted() {
return cursor > max;
}
private long remaining() {
return max - cursor + 1;
}
}
}
UPDATE 和 SELECT 必须放在同一个事务里。少了事务,两个实例可能这样交错:A 执行完 UPDATE(max_id 变成 2000),B 紧接着 UPDATE(max_id 变成 3000),然后 A 和 B 都去 SELECT,读到的都是 3000,两个实例就发了同一段号。TransactionTemplate 保证了这两条语句要么一起提交,要么一起回滚。
cursor++ 和 isExhausted() 不需要加锁,因为整个 nextId() 方法已经用 synchronized 串起来了。这里用 volatile 修饰 current、next 是为了让预取线程之外的读操作能看到最新值(如果你后面改造成异步预取,这一点就变得关键)。
启动后可以先跑一遍验证:
curl http://localhost:8080/id/snowflake
# 247994096541634560
curl http://localhost:8080/id/segment
# 2
curl "http://localhost:8080/id/batch?size=5"
# [247994096541634561,247994096541634562,247994096541634563,247994096541634564,247994096541634565]
四、踩坑经验和最佳实践
workerId 冲突是最常见的事故源。
我见过最离谱的一次:运维把 worker-id 写在了 application.yml 里,然后拿同一个 ConfigMap 滚了全部副本。新加的第四个实例没改配置,workerId 还是 3,跟前一台完全一样。上线两小时后订单号开始重复,因为两个实例刚好在同一毫秒里发了同一个序列号。
WorkerIdAllocator 把这件事交给运行环境自己回答,配置里少一个能写错的字段,就少一类事故。
还有一种情况:Pod 扩容到超过 32 个。ordinal % 32 会绕回来,id-gen-32 和 id-gen-0 撞在一起。这种时候要么把 worker 位从 5 位扩到 7 位(序列位就得缩到 10 位,每毫秒只剩 1024 个号),要么直接用号段模式——号段模式从根上没有 workerId 这个概念。
回拨异常不能吞。
有同事在 nextId() 外面套了 try-catch,捕获 IllegalStateException 之后 continue 重试。结果时钟回拨那 800 毫秒里,这个循环疯狂空转,把 CPU 打满,还一单都没发出去。回拨是基础设施问题,必须让上层知道。正确的处理是返回业务错误码,让前端提示“系统繁忙”,同时立刻告警。
JS 精度丢失。
18 位的 ID 传到前端变成 247994096541634560 末尾带一堆 0,这不是巧合,是 double 精度只有 15 到 17 位有效数字。Spring Boot 里最省事的解法是把所有 Long 序列化成字符串:
package com.example.idgen.config;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class JacksonConfig {
@Bean
public SimpleModule longToStringModule() {
SimpleModule module = new SimpleModule();
module.addSerializer(Long.class, ToStringSerializer.instance);
module.addSerializer(Long.TYPE, ToStringSerializer.instance);
return module;
}
}
序列号打满会导致 RT 抖动。
一毫秒 4096 个号,听起来很多。但批量插入场景下,一个 5000 条的批量操作就会在 1 毫秒内把序列打满,后续请求全部自旋等下一毫秒。压测时看到 P99 突然飙高,先看看是不是发号量超过 4096/毫秒。超过就该换号段模式,或者把序列位扩到 13 位(改成每机房 16 台机器)。
分库分表时别直接按 ID 取模。
雪花 ID 的低位是序列号,取模之后数据分布不均。要么取 ID 的哈希,要么用“基因法”:把分表位直接编进 ID 的某一段,查询时从 ID 里解出来就能定位到表。这是另一篇文章的话题,先记住别对原始 ID 做 % 16 就行。
五、性能对比和技术选型
单机压测(4 核 8G,MySQL 同机部署),四种方案的表现:
| 方案 | 单机 QPS | 是否趋势递增 | 依赖 | 适用场景 |
|---|---|---|---|---|
| 数据库自增 | 约 3 千 | 是 | MySQL | 单库、量小的内部系统 |
| Redis INCR | 约 8 万 | 是 | Redis | 已有 Redis、能接受网络往返 |
| UUID v4 | 约 200 万 | 否 | 无 | 日志追踪、非主键 ID |
| 雪花算法 | 约 300 万 | 是 | 本地时钟 | 订单、支付等核心主键 |
| 号段模式(步长 1000) | 约 200 万 | 是 | MySQL | 高并发、要求绝对不撞号 |
怎么选,我的建议是按业务重要性分:
- 订单号、支付流水号:号段模式。它不依赖时钟,这是它最大的优势。数据库挂了号段还能撑一段时间,够你切库。
- 日志 ID、消息 ID、链路追踪 ID:雪花算法。丢了也无所谓,但要求足够快、足够短。
- 内部管理系统的自增编号:数据库自增。别过度设计,一天几千条数据用什么雪花。
- 绝对不要:用 UUID 当 InnoDB 主键。这是拿插入性能换“省事”,几千万数据之后你会想删库重来。
如果既要趋势递增又要绝对可靠,可以用美团 Leaf 那种“号段 + 雪花”的混合模式:用号段服务批量发 workerId,雪花算法负责拼装。多了一次网络调用,但 workerId 永远不会重复。
六、总结
雪花算法的本质是“用时间换唯一性”,它把分布式唯一性这个难题压缩到了本地时钟上。时钟准,它就完美;时钟不准,它就批量出错。
四件事记住就够了:
- workerId 不要手工写死,用 StatefulSet 序号、数据库自增或者 Redis 抢槽位,任何手工配置的编号在扩容时都会变成事故。
- 回拨要显式处理,小幅等待、大幅抛异常,绝不能静默吞掉异常然后重试。
- 对时钟敏感的链路,优先考虑号段模式,它把唯一性的责任交给了数据库行锁,比 NTP 靠谱得多。
- 18 位 ID 出后端之前转成字符串,否则前端拿到的就是一堆末尾带 0 的假数字。
那次事故最后怎么解决的?把 workerId 改成从 Pod 名解析,给 chrony 配了 makestep 1.0 3(只在启动后的前三次同步允许步进,之后只做微调),同时给发号器加了回拨监控指标。三个改动之后,同类问题再没出现过。
参考资料
文 / 会编程的吕洞宾