全部文章

雪花算法生成重复订单号 时钟回拨4步防住

会编程的吕洞宾约 33 分钟

凌晨两点,订单表唯一索引突然报冲突。查出来两条订单的 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,只要出现下面任何一种情况就会重复:

  • 同一个镜像起了多个副本
  • 扩容时复制了一份配置
  • 换机器但没改配置
  • 灰度环境和生产环境用了同一份配置

正确的做法是让程序自己抢一个唯一编号,并且带续租。常见方案:

  1. 数据库自增表:启动时 INSERT 一条记录拿到自增 ID,按 id % 32 取模当 workerId,同时写心跳时间。
  2. Redis:INCR 一个 key,或者用 SETNX 抢槽位,配合过期时间做租约。
  3. ZooKeeper/etcd:创建临时顺序节点,连接断开自动释放。
  4. 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(只在启动后的前三次同步允许步进,之后只做微调),同时给发号器加了回拨监控指标。三个改动之后,同类问题再没出现过。

参考资料

文 / 会编程的吕洞宾