知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
## 为什么需要分布式 ID 单机系统用数据库自增主键就够了,但分布式环境下:  分布式 ID 的核心需求: - **全局唯一**:多节点、多分片不能重复 - **趋势递增**:方便数据库索引(B+ 树顺序写入性能好) - **高性能**:每秒能生成几十万甚至百万级 ID - **高可用**:ID 生成服务不能成为单点故障 --- ## 方案一:UUID ```java String id = UUID.randomUUID().toString(); // 输出:550e8400-e29b-41d4-a716-446655440000 ``` ### 原理及优缺点 - 原理:128 位随机数,由时间戳、MAC 地址、随机数等组合生成。 - 优点:本地生成,无网络开销,性能极高,无需中心节点 - 缺点:比较占内存,**无序,做主键容易造成页分裂,性能较差**,不可读,不包含业务信息 - 适用场景:日志 traceId、临时文件名等对有序性无要求的场景。**不适合做数据库主键。** --- ## 方案二:数据库自增(号段模式) 基础版:数据库自增id,每次生成都要访问数据库,性能瓶颈明显 进阶版:号段模式,依次从数据库取一批ID(号段),缓存在内存中分配。 表结构: 业务标识 下一次要分配的id 步长(一次取多少个) - step设置多大取决于业务的QPS,步长过大时没用完(服务重启时)会浪费掉,过小时会频繁访问数据库,造成数据库压力。 ```java // 号段模式伪代码 public class SegmentIdGenerator { private AtomicLong currentId; private long maxId; public synchronized long nextId() { if (currentId.get() >= maxId) { // 号段用完,从数据库加载下一个号段 loadNextSegment(); } return currentId.getAndIncrement(); } private void loadNextSegment() { // UPDATE id_alloc SET max_id = max_id + step WHERE biz_tag = ? // currentId = 旧 max_id + 1 // maxId = 新 max_id } } ```` ### 双 Buffer 优化 - 号段模式的问题:号段用完时去数据库取,会有短暂阻塞 - 解决方法:双 Buffer,当前号段用到 10% 剩余时,异步加载下一个号段 ``` ┌─────────────────────────────────────┐ │ Buffer 1: [2001, 3000] ← 正在使用 │ │ Buffer 2: [3001, 4000] ← 提前加载 │ └─────────────────────────────────────┘ Buffer 1 用到 2800 时 → 异步线程加载 Buffer 2 Buffer 1 用完 → 无缝切换到 Buffer 2 同时异步加载 Buffer 1 的下一个号段 ```  > 💬 **Q:如果号段模式原来有两个节点,A 拿到 `1-5`,B 拿到 `6-10`,这时突然新加入一个节点怎么办?** > > 这种场景**完全可能,而且很常见**。比如: > - Kubernetes 自动扩容,新起一个 Pod > - 流量高峰临时加机器 > - 某个实例重启后重新加入集群 > > 注意:这里说的 A/B/C,指的是**发号器实例/业务服务实例**,不是后面分库分表里的**数据库分片节点**。 > > 号段模式对这种场景的处理非常自然:**新节点不会去抢老节点手里的号段,而是直接向数据库申请“下一段”**。 > > 假设 `step=5`,当前状态是: > > ``` > 节点 A 持有 [1, 5] > 节点 B 持有 [6, 10] > 数据库里 max_id = 10 > ``` > > 此时新节点 C 启动,也会执行同样的原子操作: > > ```sql > UPDATE id_alloc SET max_id = max_id + step WHERE biz_tag = 'order'; > SELECT max_id, step FROM id_alloc WHERE biz_tag = 'order'; > ``` > > 数据库把 `max_id` 从 `10` 改成 `15`,于是: > > ``` > 节点 C 拿到 [11, 15] > ``` > > 也就是说: > - A 继续发自己的 `1-5` > - B 继续发自己的 `6-10` > - C 开始发自己的 `11-15` > - 三者**不会重复** > > **为什么不会冲突?** > > 因为号段的分配依赖数据库那一行记录的原子更新,谁先拿到行锁,谁先把 `max_id` 往后推进一段。后来的节点只能拿到再后面的一段。 > > **但要注意两个现象:** > > 1. **可能跳号** > > 如果节点 A 只发到了 `3` 就宕机了,那么 `4、5` 这两个 ID 很可能就浪费掉了。系统不会回收这部分号段,而是继续往后分配。 > > 2. **不是严格按生成时间全局递增** > > 虽然号段是按区间递增分配的,但不同节点发号速度不同,最终请求拿到的 ID 顺序可能是乱的。 > > 例如: > > ``` > A 当前准备发 4 > B 当前准备发 9 > C 刚加入,已经拿到 11 > > 实际请求顺序可能是: > 11 → 4 → 9 → 12 → 5 → 10 > ``` > > 所以号段模式保证的是: > - **全局唯一** > - **整体趋势递增** > > 但不保证: > - **严格连续** > - **按请求到达时间严格单调递增** > 💬 **Q:如果这里的“节点”指的是数据库节点/分库节点,那 ID 规则是不是要更新?** > > 这要分两种情况看: > > **情况 1:数据库节点只是主从复制/高可用节点** > > 这种情况下,**ID 分配规则通常不用改**。因为真正分配号段的还是同一个逻辑主库上的 `id_alloc` 表,从库只是做复制或容灾。 > > 例如: > > ``` > ID 分配库: > Master:负责 UPDATE max_id > Slave1:只读副本 > Slave2:只读副本 > ``` > > 只要发号请求都打到可写主库,规则还是: > > ```sql > UPDATE id_alloc SET max_id = max_id + step WHERE biz_tag = 'order'; > ``` > > 所以这里扩容的是数据库高可用能力,不是发号规则本身。 > > **情况 2:数据库节点是多个独立分片,而且每个分片都想自己发 ID** > > 这时就**不能继续用完全相同的发号规则**了,否则不同分片各自维护自己的 `max_id`,很容易发出重复 ID。 > > 比如两个分片都从 1 开始: > > ``` > 分片 DB1:1, 2, 3, 4, 5 > 分片 DB2:1, 2, 3, 4, 5 > ``` > > 那全局一定冲突。 > > 这时常见有三种做法: > > 1. **独立的全局发号中心** > > 最推荐。也就是业务库怎么分片都没关系,所有分片统一向一个 ID 服务申请号段。这样数据库节点增减不会影响 ID 规则。 > > 2. **按库分配不同区间** > > 例如: > > ``` > DB1 只发 [1, 1000000] > DB2 只发 [1000001, 2000000] > DB3 新增后发 [2000001, 3000000] > ``` > > 这样新增数据库节点时,需要给它规划新的区间。 > > 3. **步长 + 偏移** > > 例如 2 个数据库节点时: > > ``` > DB1:1, 3, 5, 7, ... > DB2:2, 4, 6, 8, ... > ``` > > 这里规则就是: > - `step = 2` > - DB1 的 offset = 1 > - DB2 的 offset = 2 > > 但如果从 2 个库扩成 3 个库,规则就要从“模 2”变成“模 3”: > > ``` > DB1:1, 4, 7, 10, ... > DB2:2, 5, 8, 11, ... > DB3:3, 6, 9, 12, ... > ``` > > 这就意味着**发号规则确实要更新**,而且迁移很麻烦,因为旧规则生成中的 ID 和新规则需要平滑共存。 > > **所以结论是:** > > - 如果“节点”指的是业务服务实例:通常不用改规则,新实例拿下一段即可 > - 如果“节点”指的是数据库高可用副本:通常也不用改规则 > - 如果“节点”指的是多个独立分库,并且每个库都自己发号:**是的,规则往往要更新** > > 也正因为如此,工程上一般不推荐把“ID 生成规则”直接绑定到“数据库分片个数”。更稳妥的方式是把 ID 生成独立出去,让数据库怎么扩容都不影响发号规则。 ### 优缺点和实现补充 ### 优缺点 | 优点 | 缺点 | |------|------| | ID 有序递增,数据库友好 | 依赖数据库,需要保证数据库高可用 | | 号段模式减少数据库访问 | ID 不连续(服务重启会跳号) | | 实现简单,容易理解 | 号段长度需要根据业务调优 | --- ## 方案三:Snowflake(雪花算法)⭐ 最常用 ### 原理 Twitter 开源的分布式 ID 算法,生成 64 位 long 型 ID: 1(符号位,固定0)+41(时间戳,可用69年)+5(数据中心ID)+5(机器ID)+12(序列号) - 12位的序列号代表每毫秒每台机器可以生成2^12=4096个ID - 每秒单机:4096 × 1000 = 409.6 万个 ID ### 时钟回拨问题 ``` 这是 Snowflake 最大的坑: NTP 时间同步可能导致系统时钟往回跳 时间线:10:00:00.100 → 10:00:00.099(回拨了 1ms) 如果不处理: 10:00:00.100 生成了 ID = 100xxx 10:00:00.099 又生成了 ID = 99xxx → ID 重复! 处理方案: 1. 直接抛异常拒绝(上面代码的做法,简单粗暴) 2. 等待时钟追上(小幅回拨时可用) 3. 用扩展位记录回拨次数(美团 Leaf 的做法) ```   ### 优缺点 | 优点 | 缺点 | |------|------| | 本地生成,性能极高(单机 400 万/秒) | 依赖机器时钟,时钟回拨会出问题 | | 趋势递增,数据库索引友好 | 需要手动分配 workerId | | 不依赖第三方组件 | 不是严格递增(不同机器间无序) | | ID 中包含时间信息,可反解 | 69 年后时间戳溢出(实际够用) | ### Snowflake 算法深度解析 Snowflake 是 Twitter 开源的分布式 ID 生成算法,生成 64 位长整型 ID。 ``` Snowflake ID 结构(64 位): ┌──┬───────────────────────────┬──────────┬──────────────────┐ │ 1│ 41 bit │ 10 bit │ 12 bit │ │bit│ 时间戳(毫秒) │ 机器 ID │ 序列号(自增) │ │ │ │ │ │ │ │ 从自定义起始时间开始 │ 5bit机房 │ 每毫秒内自增 │ │ │ 约 69 年可用 │ +5bit机器│ 最多 4096 个/ms │ │ │ │ =1024 台│ │ └──┴──────────────────────────┴──────────┴──────────────────┘ 符号位(固定为 0,保证 ID 为正数) 示例:假设起始时间 = 2020-01-01 00:00:00 当前时间:2024-01-15 10:30:00.500 距起始时间 = 4年 × 365天 × 24h × 3600s × 1000ms ≈ 126230400000 ms 机器ID = 机房1 + 机器3 = 0b00001 00011 = 35 序列号 = 当前毫秒内的第 127 个请求 生成的 ID(十进制):7438938941272886355 计算过程: timestamp = 126230400500 - START_EPOCH = 某值 id = (timestamp << 22) | (datacenterId << 17) | (workerId << 12) | sequence  Snowflake 的优势: ├── 高性能:本地生成,无网络开销,单机约 4 万 QPS ├── 趋势递增:时间戳在高位,整体递增,对数据库索引友好 ├── 分布式友好:不同机器 ID 互不冲突,不需要中心协调 └── 可配置:位数可调整(如减少机器位、增加序列位) Snowflake 的两个核心问题: 问题 1:时钟回拨(回调) 场景:NTP 时钟同步把机器时间往回拨了 50ms 问题:同一机器在回拨期间可能生成重复 ID 解决方案: ① 等待:检测到回拨后,sleep 到时间追上 ② 容忍短暂回拨(< 5ms):记住上一条 ID 的时间戳, 如果新时间 < 旧时间但差值 < 5ms,继续用旧时间戳 + 序列号自增 ③ 使用备用机器 ID:回拨期间换个机器 ID 问题 2:机器 ID 分配 问题:1024 台机器的机器 ID 怎么分配?手动配置?自动注册? 常见方案: ├── 配置文件:运维手动分配(小规模适用) ├── 基于 IP:把 IP 哈希 => 机器 ID(水平扩容友好) ├── ZK 临时顺序节点:启动时注册,获取递增序号作为机器 ID └── 数据库自增:启动时 insert 一条记录,拿回自增 ID ID 生成性能对比: UUID DB 号段 Redis INCR Snowflake ┌─────────────────────────────────────────────────────────────────┐ │ 生成方式 本地生成 访问 DB 访问 Redis 本地生成 │ │ QPS 极高(无IO) 高(批量取) 高(单点) 极高(无IO) │ │ 趋势递增 ✗ (乱序) ✓ (趋势) ✓ (严格) ✓ (趋势) │ │ 不依赖DB ✓ ✗ ✗ ✓ │ │ 依赖时钟 ✗ ✗ ✗ ✓ (时钟敏感) │ │ 长度 36 字符 8 字节 8 字节 8 字节 │ │ 适用场景 traceId 大部分业务 严格递增 大部分业务 │ └─────────────────────────────────────────────────────────────────┘ ``` --- ## 方案四:Redis INCR ```java // 利用 Redis 的原子自增 Long id = redisTemplate.opsForValue().increment("order:id"); // 加上日期前缀,避免 ID 过大 String orderId = LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE) + String.format("%06d", id); // 输出:20240115000001 ``` ### 优缺点 | 优点 | 缺点 | |------|------| | 严格递增 | 依赖 Redis,需要保证高可用 | | 实现简单 | 网络开销(每次都要访问 Redis) | | 天然支持分布式 | Redis 宕机可能丢数据(RDB 模式) | --- ## 方案五:美团 Leaf 美团开源的分布式 ID 生成系统,同时支持号段模式和 Snowflake 模式。 ``` Leaf 架构: ┌──────────┐ ┌──────────────┐ ┌──────────┐ │ 业务服务 │ ──→ │ Leaf Server │ ──→ │ 数据库 │ │ │ │ (HTTP/RPC) │ │ (号段模式) │ └──────────┘ │ │ └──────────┘ │ 或 │ ┌──────────┐ │ │ ──→ │ ZooKeeper │ │ │ │(Snowflake)│ └──────────────┘ └──────────┘ 号段模式:Leaf-Segment(双 Buffer + 数据库) 雪花模式:Leaf-Snowflake(ZooKeeper 分配 workerId) ``` ### Leaf-Snowflake 的 workerId 分配 ``` 手动分配 workerId 容易出错,Leaf 用 ZooKeeper 自动分配: 1. 服务启动 → 在 ZooKeeper 创建临时顺序节点 /leaf/snowflake/order/worker-0000000001 /leaf/snowflake/order/worker-0000000002 2. 节点序号就是 workerId(自动分配,不会重复) 3. 服务下线 → 临时节点自动删除 → workerId 可复用 ``` --- ## 方案对比 | 方案 | 有序性 | 性能 | 可用性 | 实现复杂度 | 适用场景 | |------|--------|------|--------|-----------|---------| | UUID | 无序 | 极高 | 极高 | 极低 | 日志 traceId | | 数据库自增 | 严格递增 | 低 | 依赖 DB | 低 | 小规模系统 | | 号段模式 | 趋势递增 | 高 | 依赖 DB | 中 | 中大规模系统 | | Snowflake | 趋势递增 | 极高 | 极高 | 中 | 大规模系统(推荐) | | Redis INCR | 严格递增 | 中 | 依赖 Redis | 低 | 中小规模系统 | | 美团 Leaf | 两种模式 | 高 | 高 | 高 | 企业级生产环境 | --- ## 面试高频问题 ### Q1:你们项目用的什么分布式 ID 方案? **A:** 大多数互联网公司用 Snowflake 或其变种(美团 Leaf-Snowflake、百度 UidGenerator)。原因:本地生成性能高、趋势递增对数据库友好、不依赖外部存储。 ### Q2:Snowflake 的时钟回拨怎么处理? **A:** 三种策略:① 小幅回拨(<5ms)直接等待;② 大幅回拨抛异常告警;③ 用扩展位记录回拨次数(美团 Leaf 的做法,牺牲一点序列号空间换取容错)。 ### Q3:为什么不用 UUID 做数据库主键? **A:** UUID 无序,插入 B+ 树时会导致频繁的页分裂和随机 IO,性能比自增 ID 差很多。而且 UUID 是 36 字符的字符串,存储空间是 bigint 的 4.5 倍。 ### Q4:Snowflake 的 workerId 怎么分配? **A:** 几种方式:① 手动配置(小规模);② ZooKeeper 临时顺序节点自动分配(美团 Leaf);③ 从 IP 地址或容器 ID 中提取(简单但有冲突风险);④ 数据库注册表(启动时注册,定期心跳续约)。 ### Q5:号段模式的 step 设多大合适? **A:** 根据业务 QPS 估算。假设 QPS=1000,希望每 15 分钟取一次号段,则 step = 1000 × 60 × 15 = 90 万。太小会频繁访问数据库,太大会导致服务重启时浪费大量 ID。 ### Q6:号段模式下,新节点动态加入会不会出问题? **A:** 正常不会。新节点不会抢老节点手里的号段,而是启动后再去数据库申请“下一段”。例如 A 持有 `1-5`、B 持有 `6-10`,这时新节点 C 加入,只要当前 `max_id=10`、`step=5`,C 就会拿到 `11-15`。因为数据库通过原子 `UPDATE` 推进 `max_id`,所以不会重复。 但要明确两点: 1. 号段模式允许**跳号**。某个节点宕机时没发完的区间通常不会回收。 2. 号段模式只是**趋势递增**,不是“按请求时刻严格全局递增”。A 可能后发出 `4`,而 C 已经先发出了 `11`。 ### Q7:如果这里的“节点”其实是数据库分片节点,ID 规则是不是要更新? **A:** 如果是数据库高可用里的主从节点,通常不用改,发号还是由同一个逻辑主库上的 `id_alloc` 表负责;但如果是多个独立分库,而且每个库都想自己发 ID,那规则通常就要重新设计,否则各库会各自从 1 开始,导致全局冲突。 常见方案有三种: 1. 独立全局发号中心:最推荐,业务分库数量变化不影响 ID 规则。 2. 每个库分配固定区间:新增分库时给它新号段区间。 3. 步长 + 偏移:比如两个库分别发奇数和偶数。 其中“步长 + 偏移”在数据库节点数变化时最麻烦。比如原来 2 个库按奇偶发号,后来扩成 3 个库,就要从“模 2”规则切到“模 3”规则,迁移成本高,所以一般不建议把 ID 生成规则直接和数据库分片数绑定。 --- 上一篇:[10 - 分布式缓存与数据库](./10-distributed-cache-db.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入