分布式系统中的ID策略：从理论到落地的全方位指南

2026-04-19 09:31:01作者：庞眉杨Will

AI低代码平台，支持「低代码 + 零代码」双模式：零代码 5 分钟搭建业务系统，低代码模式一键生成前后端代码。内置AI 应用，支持AI聊天、知识库、流程编排、MCP与插件，支持各种模型。Skills能力实现：一句话画流程图、设计表单、生成系统。引领 AI生成→在线配置→代码生成→手工合并的开发模式，解决Java项目80%的重复工作，快速提高效率，又不失灵活性。

项目地址：https://gitcode.com/GitHub_Trending/je/jeecg-boot

问题引入：当订单号重复时，我们在争什么？

想象这样一个场景：电商平台的促销活动中，两位用户同时下单，系统却生成了相同的订单号。这不仅仅是一个数字重复的问题，它可能导致库存扣减错误、支付混乱，甚至引发用户投诉和财务风险。在分布式系统中，这种ID冲突问题比你想象的更为普遍。

分布式ID（Distributed ID）是指在分布式系统中生成的全局唯一标识符，它需要满足唯一性、有序性、高可用性和安全性等核心要求。JeecgBoot作为企业级低代码平台，其ID生成策略直接关系到系统的稳定性和可扩展性。

[!TIP] 据阿里云技术团队统计，分布式系统中约30%的线上故障与ID生成策略不当有关，其中ID冲突导致的数据不一致问题占比最高，达42%。

技术原理：三种主流ID生成算法深度解析

1. 雪花算法（Snowflake）：时间与空间的精妙组合

雪花算法就像一个精密的钟表，将64位ID划分为不同的"时间刻度"和"空间坐标"：

/**
 * 雪花算法ID生成器实现
 * 结构：0-41位时间戳-10位机器码-12位序列号
 */
public class SnowflakeIdGenerator {
    // 起始时间戳 (2023-01-01)
    private final long twepoch = 1672502400000L;
    // 机器ID位数
    private final long workerIdBits = 10L;
    // 序列号位数
    private final long sequenceBits = 12L;
    
    // 最大机器ID (1023)
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    // 最大序列号 (4095)
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    
    private long workerId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;
    
    public SnowflakeIdGenerator(long workerId) {
        // 校验机器ID合法性
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(
                String.format("Worker ID can't be greater than %d or less than 0", maxWorkerId));
        }
        this.workerId = workerId;
    }
    
    /**
     * 生成下一个ID
     * @return 64位雪花ID
     */
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        
        // 处理时钟回拨问题
        if (timestamp < lastTimestamp) {
            long offset = lastTimestamp - timestamp;
            if (offset <= 5) { // 允许5ms内的回拨
                try {
                    wait(offset << 1); // 等待两倍偏移时间
                    timestamp = System.currentTimeMillis();
                    if (timestamp < lastTimestamp) {
                        throw new RuntimeException(
                            String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", offset));
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException("Generate ID interrupted", e);
                }
            } else {
                throw new RuntimeException(
                    String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", offset));
            }
        }
        
        // 同一毫秒内序列号递增
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            // 序列号溢出，等待下一毫秒
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        
        lastTimestamp = timestamp;
        
        // 组合ID：时间戳左移22位 + 机器ID左移12位 + 序列号
        return ((timestamp - twepoch) << (workerIdBits + sequenceBits))
            | (workerId << sequenceBits)
            | sequence;
    }
    
    // 等待到下一毫秒
    private long tilNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

生活化类比：雪花算法就像图书馆的索书号——时间戳是"出版年份"，机器码是"书架编号"，序列号是"同一本书的不同副本编号"。即使两本书同年出版（相同时间戳）、放在同一个书架（相同机器码），也会因为副本编号不同而拥有唯一的索书号。

2. UUID/GUID：随机的艺术

UUID（Universally Unique Identifier）是另一种常见的ID生成方案，它通过MAC地址、时间戳、随机数等信息生成128位的唯一标识符：

/**
 * UUID生成策略示例
 */
public class UuidGenerator {
    /**
     * 生成基于随机数的UUID (UUID v4)
     * @return 36位UUID字符串
     */
    public String generateRandomUuid() {
        return UUID.randomUUID().toString();
    }
    
    /**
     * 生成基于名称和命名空间的UUID (UUID v5)
     * @param name 名称
     * @param namespace 命名空间UUID
     * @return 36位UUID字符串
     */
    public String generateNameBasedUuid(String name, UUID namespace) {
        return UUID.nameUUIDFromBytes(
            ByteBuffer.allocate(16 + name.getBytes(StandardCharsets.UTF_8).length)
                .putLong(namespace.getMostSignificantBits())
                .putLong(namespace.getLeastSignificantBits())
                .put(name.getBytes(StandardCharsets.UTF_8))
                .array()
        ).toString();
    }
}

生活化类比：UUID就像我们的指纹——虽然理论上存在重复的可能性（概率约为1/10³⁶），但在实际应用中可以认为是唯一的。不过，就像指纹不包含任何身份信息一样，UUID也不包含时间和顺序信息。

3. 数据库自增ID：简单中的复杂

数据库自增ID是最传统的ID生成方式，通过数据库的自增机制保证唯一性：

-- MySQL自增ID表定义
CREATE TABLE `sequence` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `biz_type` varchar(64) NOT NULL COMMENT '业务类型',
  `max_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '当前最大ID',
  `step` int(11) NOT NULL DEFAULT '1' COMMENT '步长',
  `gmt_modified` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_biz_type` (`biz_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='分布式ID序列表';

-- 获取下一个ID的存储过程
DELIMITER $$
CREATE PROCEDURE `next_id`(
  IN bizType VARCHAR(64),
  OUT result BIGINT
)
BEGIN
  DECLARE currentMaxId BIGINT;
  DECLARE step INT;
  
  -- 开启事务
  START TRANSACTION;
  
  -- 查询当前最大值和步长
  SELECT max_id, step INTO currentMaxId, step FROM sequence WHERE biz_type = bizType FOR UPDATE;
  
  -- 如果记录不存在则初始化
  IF currentMaxId IS NULL THEN
    SET currentMaxId = 0;
    SET step = 1;
    INSERT INTO sequence (biz_type, max_id, step) VALUES (bizType, currentMaxId + step, step);
  ELSE
    -- 更新最大值
    UPDATE sequence SET max_id = currentMaxId + step WHERE biz_type = bizType;
  END IF;
  
  -- 设置返回结果
  SET result = currentMaxId + 1;
  
  -- 提交事务
  COMMIT;
END$$
DELIMITER ;

生活化类比：数据库自增ID就像电影院的座位号——每个影厅（业务类型）有独立的编号序列，由售票系统（数据库）统一分配，确保不会重复。但如果只有一个售票窗口（单库单表），在高峰期就会出现排队现象。

场景适配：技术选型决策树与实施路径

技术选型决策树

选择合适的ID生成策略需要考虑多个因素，以下决策树可帮助你快速定位适合的方案：

是否需要有序性？
- 是 → 2
- 否 → UUID/GUID
是否需要趋势递增？
- 是 → 3
- 否 → 分布式ID生成服务（如美团Leaf、百度UidGenerator）
系统规模？
- 中小规模（QPS < 1万） → 数据库自增ID
- 中大规模（QPS 1万-10万） → 雪花算法
- 超大规模（QPS > 10万） → 分布式ID生成服务 + 号段模式

不同规模企业的实施路径

初创企业（团队规模<50人）

推荐方案：数据库自增ID + 分库分表中间件
实施步骤：
1. 初期使用单库自增ID
2. 业务增长后引入Sharding-JDBC实现分库分表
3. 为核心业务表（如订单表）配置独立的ID生成策略

中型企业（团队规模50-200人）

推荐方案：雪花算法 + 配置中心
实施步骤：
1. 实现基于雪花算法的ID生成器
2. 通过配置中心（如Nacos）管理机器ID
3. 建立ID生成监控告警机制
4. 关键业务实施ID生成降级方案

大型企业（团队规模>200人）

推荐方案：分布式ID服务 + 多策略适配
实施步骤：
1. 部署独立的ID生成服务集群
2. 实现多策略适配（雪花算法、号段模式等）
3. 建立ID生成熔断和限流机制
4. 实施ID生成全链路追踪

落地实践：JeecgBoot中的ID策略实现

JeecgBoot采用了灵活的ID生成策略，通过抽象基类实现统一管理，同时支持自定义扩展。

1. 默认实现：基于雪花算法的ASSIGN_ID

JeecgBoot的实体类统一继承JeecgEntity基类，该基类使用MyBatis-Plus的IdType.ASSIGN_ID策略：

package org.jeecg.common.system.base.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.io.Serializable;

/**
 * JeecgBoot实体基类
 * 所有业务实体类应继承此类，统一ID生成策略
 */
@Data
public class JeecgEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * ID字段
     * 使用雪花算法生成全局唯一ID
     */
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "ID")
    private String id;
    
    // 其他公共字段...
}

2. 自定义ID生成器实现

对于特殊业务场景，JeecgBoot支持自定义ID生成器：

package org.jeecg.common.util;

import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import org.springframework.stereotype.Component;

import java.util.concurrent.atomic.AtomicLong;

/**
 * 自定义订单号生成器
 * 格式：年月日 + 业务编码 + 序列号
 */
@Component
public class OrderIdGenerator implements IdentifierGenerator {
    
    // 业务编码映射
    private static final String BIZ_CODE = "ORD";
    // 序列号计数器
    private final AtomicLong sequence = new AtomicLong(1);
    
    @Override
    public Serializable nextId(Object entity) {
        // 获取当前日期，格式：YYYYMMDD
        String date = DateUtils.format(new Date(), "yyyyMMdd");
        // 获取序列号，6位，不足补零
        String seq = String.format("%06d", sequence.getAndIncrement() % 1000000);
        // 组合订单号
        return date + BIZ_CODE + seq;
    }
}

3. 配置模板：雪花算法机器ID配置

在application.yml中配置雪花算法相关参数：

# JeecgBoot 雪花算法配置
jeecg:
  snowflake:
    # 机器ID (0-31)，分布式部署时需确保唯一
    worker-id: ${WORKER_ID:0}
    # 数据中心ID (0-31)
    datacenter-id: ${DATACENTER_ID:0}
    # 是否使用UUID作为备选方案
    use-uuid-backup: true
    # 时钟回拨容忍时间(ms)
    max-clock-backward: 5

性能测试方法论：如何验证你的ID生成策略

1. 基准测试指标

指标	定义	测量方法
吞吐量	单位时间内生成的ID数量	固定时间内生成ID总数 / 时间(秒)
响应时间	生成单个ID的平均耗时	总耗时 / 生成ID总数
可用性	ID生成服务的可用时间占比	(总时间 - 不可用时间) / 总时间
唯一性	生成ID的重复率	重复ID数量 / 总生成ID数量
有序性	ID的单调递增程度	逆序ID对数 / 总ID对数

2. 测试工具与环境

推荐使用JMeter或Gatling进行性能测试，测试环境应模拟生产环境的服务器配置和网络状况：

# JMeter测试计划示例
jmeter -n -t id-generator-test.jmx -l test-results.jtl -e -o report

3. 测试场景设计

单节点基准测试：测试单个ID生成节点的极限性能
多节点并发测试：模拟分布式环境下的并发ID生成
故障恢复测试：模拟节点宕机后的恢复能力
时钟回拨测试：模拟服务器时钟异常时的处理能力
长期稳定性测试：持续24小时以上的ID生成测试

生产环境问题排查案例

案例1：时钟回拨导致的ID重复

现象：某电商平台在服务器时间同步后出现订单ID重复。

排查过程：

查看ID生成日志，发现重复ID集中在时间调整后的5分钟内
检查雪花算法实现，发现未处理时钟回拨问题
验证服务器NTP配置，发现时间同步间隔设置过大

解决方案：

// 改进的时钟回拨处理逻辑
if (timestamp < lastTimestamp) {
    long offset = lastTimestamp - timestamp;
    if (offset <= maxClockBackward) {
        // 小幅度回拨，等待恢复
        try {
            Thread.sleep(offset << 1);
            timestamp = System.currentTimeMillis();
        } catch (InterruptedException e) {
            log.error("Clock backward sleep interrupted", e);
        }
    } else {
        // 大幅度回拨，使用UUID作为备选
        if (useUuidBackup) {
            return UUID.randomUUID().toString();
        } else {
            throw new RuntimeException("Clock moved backwards too much");
        }
    }
}

案例2：数据库自增ID性能瓶颈

现象：某支付系统在促销活动期间出现订单创建延迟，数据库连接池耗尽。

排查过程：

监控显示数据库连接池使用率100%
慢查询日志显示大量获取自增ID的SQL等待锁
分析发现订单表和支付表使用同一数据库实例的自增ID

解决方案：

引入号段模式ID生成器
为不同业务表配置独立的号段
实现本地缓存号段，减少数据库访问

案例3：UUID作为数据库主键的性能问题

现象：某用户系统在数据量达到千万级后，查询性能急剧下降。

排查过程：

分析执行计划发现主键索引查询效率低下
检查表结构发现使用UUID作为主键
查看索引物理存储，发现索引页分裂严重

解决方案：

改用雪花算法生成有序ID
实施数据迁移，逐步替换UUID主键
对历史数据建立UUID到新ID的映射表

边缘计算场景适配：分布式ID的新挑战

随着边缘计算的兴起，ID生成策略面临新的挑战：网络不稳定、设备资源有限、离线工作需求等。

边缘环境下的ID生成策略

本地化预生成：在网络良好时预生成一批ID并缓存
分层ID结构：包含边缘节点标识、本地序列号和时间戳
冲突检测与解决：上传数据时检测并解决ID冲突

实现示例：边缘设备ID生成器

public class EdgeIdGenerator {
    // 边缘节点ID
    private final String edgeNodeId;
    // 本地ID缓存
    private final Queue<String> idCache = new ConcurrentLinkedQueue<>();
    // 缓存阈值
    private final int CACHE_THRESHOLD = 1000;
    
    public EdgeIdGenerator(String edgeNodeId) {
        this.edgeNodeId = edgeNodeId;
        // 初始化缓存
        preGenerateIds(CACHE_THRESHOLD);
    }
    
    // 预生成ID
    private void preGenerateIds(int count) {
        // 仅在网络可用时执行
        if (NetworkUtils.isAvailable()) {
            try {
                // 从中心服务获取号段
                IdSegment segment = IdServiceClient.getSegment(edgeNodeId, count);
                for (long i = segment.getStart(); i < segment.getEnd(); i++) {
                    idCache.offer(edgeNodeId + "-" + i);
                }
            } catch (Exception e) {
                // 网络不可用时使用本地生成策略
                for (int i = 0; i < count; i++) {
                    String localId = edgeNodeId + "-L-" + 
                        System.currentTimeMillis() + "-" + RandomUtils.nextInt(1000);
                    idCache.offer(localId);
                }
            }
        } else {
            // 离线状态下的本地生成
            for (int i = 0; i < count; i++) {
                String localId = edgeNodeId + "-O-" + 
                    System.currentTimeMillis() + "-" + RandomUtils.nextInt(10000);
                idCache.offer(localId);
            }
        }
    }
    
    // 获取下一个ID
    public String nextId() {
        // 当缓存低于阈值时异步预生成
        if (idCache.size() < CACHE_THRESHOLD / 2) {
            CompletableFuture.runAsync(() -> preGenerateIds(CACHE_THRESHOLD));
        }
        return idCache.poll();
    }
}