当前位置： 首页 > backend >正文

基于Redis的3种分布式ID生成策略

backend 2025/5/20 7:06:19

在分布式系统设计中，全局唯一ID是一个基础而关键的组件。随着业务规模扩大和系统架构向微服务演进，传统的单机自增ID已无法满足需求。高并发、高可用的分布式ID生成方案成为构建可靠分布式系统的必要条件。

Redis具备高性能、原子操作及简单易用的特性，因此我们可以基于Redis实现全局唯一ID的生成。

分布式ID的核心需求

一个优秀的分布式ID生成方案应满足以下要求

  • 全局唯一性：在整个分布式系统中保证ID不重复
  • 高性能：能够快速生成ID，支持高并发场景
  • 高可用：避免单点故障，确保服务持续可用
  • 趋势递增：生成的ID大致呈递增趋势，便于数据库索引和分片
  • 安全性（可选） ：不包含敏感信息，不易被推测和伪造

1. 基于INCR命令的简单自增ID

原理

这是最直接的Redis分布式ID实现方式，利用Redis的INCR命令原子性递增一个计数器，确保在分布式环境下ID的唯一性。

代码实现

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;@Component
public class RedisSimpleIdGenerator {private final RedisTemplate<String, String> redisTemplate;private final String ID_KEY;public RedisSimpleIdGenerator(RedisTemplate<String, String> redisTemplate) {this.redisTemplate = redisTemplate;this.ID_KEY = "distributed:id:generator";}/*** 生成下一个ID* @return 唯一ID*/public long nextId() {Long id = redisTemplate.opsForValue().increment(ID_KEY);if (id == null) {throw new RuntimeException("Failed to generate id");}return id;}/*** 为指定业务生成ID* @param bizTag 业务标签* @return 唯一ID*/public long nextId(String bizTag) {String key = ID_KEY + ":" + bizTag;Long id = redisTemplate.opsForValue().increment(key);if (id == null) {throw new RuntimeException("Failed to generate id for " + bizTag);}return id;}/*** 获取当前ID值但不递增* @param bizTag 业务标签* @return 当前ID值*/public long currentId(String bizTag) {String key = ID_KEY + ":" + bizTag;String value = redisTemplate.opsForValue().get(key);return value != null ? Long.parseLong(value) : 0;}
}

优缺点

优点

  • 实现极其简单，仅需一次Redis操作
  • ID严格递增，适合作为数据库主键
  • 支持多业务ID隔离

缺点

  • Redis单点故障会导致ID生成服务不可用
  • 主从切换可能导致ID重复
  • 无法包含业务含义

适用场景

  • 中小规模系统的自增主键生成
  • 对ID连续性有要求的业务场景
  • 单数据中心部署的应用

2. 基于Lua脚本的批量ID生成

原理

通过Lua脚本一次性获取一批ID，减少网络往返次数，客户端可在内存中顺序分配ID，显著提高性能。

代码实现

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;@Component
public class RedisBatchIdGenerator {private final RedisTemplate<String, String> redisTemplate;private final String ID_KEY = "distributed:batch:id";private final DefaultRedisScript<Long> batchIncrScript;// 批量获取的大小private final int BATCH_SIZE = 1000;// 本地计数器和锁private AtomicLong currentId = new AtomicLong(0);private AtomicLong endId = new AtomicLong(0);private final Lock lock = new ReentrantLock();public RedisBatchIdGenerator(RedisTemplate<String, String> redisTemplate) {this.redisTemplate = redisTemplate;// 创建Lua脚本String scriptText = "local key = KEYS[1] " +"local step = tonumber(ARGV[1]) " +"local currentValue = redis.call('incrby', key, step) " +"return currentValue";this.batchIncrScript = new DefaultRedisScript<>();this.batchIncrScript.setScriptText(scriptText);this.batchIncrScript.setResultType(Long.class);}/*** 获取下一个ID*/public long nextId() {// 如果当前ID超过了分配范围，则重新获取一批if (currentId.get() >= endId.get()) {lock.lock();try {// 双重检查，防止多线程重复获取if (currentId.get() >= endId.get()) {// 执行Lua脚本获取一批IDLong newEndId = redisTemplate.execute(batchIncrScript, Collections.singletonList(ID_KEY),String.valueOf(BATCH_SIZE));if (newEndId == null) {throw new RuntimeException("Failed to generate batch ids");}// 设置新的ID范围endId.set(newEndId);currentId.set(newEndId - BATCH_SIZE);}} finally {lock.unlock();}}// 分配下一个IDreturn currentId.incrementAndGet();}/*** 为指定业务生成ID*/public long nextId(String bizTag) {// 实际项目中应该为每个业务标签维护独立的计数器和范围// 这里简化处理，仅使用不同的Redis keyString key = ID_KEY + ":" + bizTag;Long newEndId = redisTemplate.execute(batchIncrScript, Collections.singletonList(key),String.valueOf(1));return newEndId != null ? newEndId : -1;}
}

优缺点

优点

  • 显著减少Redis网络请求次数
  • 客户端缓存ID段，大幅提高性能
  • 降低Redis服务器压力
  • 支持突发流量处理

缺点

  • 实现复杂度增加
  • 服务重启可能导致ID段浪费

适用场景

  • 高并发系统，需要极高ID生成性能的场景
  • 对ID连续性要求不严格的业务
  • 能容忍小部分ID浪费的场景

3. 基于Redis的分段式ID分配（号段模式）

原理

号段模式是一种优化的批量ID生成方案，通过预分配号段（ID范围）减少服务间竞争，同时引入双Buffer机制提高可用性。

代码实现

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;@Component
public class RedisSegmentIdGenerator {private final RedisTemplate<String, String> redisTemplate;private final String SEGMENT_KEY = "distributed:segment:id";private final DefaultRedisScript<Long> segmentScript;// 号段大小private final int SEGMENT_STEP = 1000;// 加载因子，当前号段使用到这个百分比时就异步加载下一个号段private final double LOAD_FACTOR = 0.7;// 存储业务号段信息的Mapprivate final Map<String, SegmentBuffer> businessSegmentMap = new ConcurrentHashMap<>();public RedisSegmentIdGenerator(RedisTemplate<String, String> redisTemplate) {this.redisTemplate = redisTemplate;// 创建Lua脚本String scriptText = "local key = KEYS[1] " +"local step = tonumber(ARGV[1]) " +"local value = redis.call('incrby', key, step) " +"return value";this.segmentScript = new DefaultRedisScript<>();this.segmentScript.setScriptText(scriptText);this.segmentScript.setResultType(Long.class);}/*** 获取下一个ID* @param bizTag 业务标签* @return 唯一ID*/public long nextId(String bizTag) {// 获取或创建号段缓冲区SegmentBuffer buffer = businessSegmentMap.computeIfAbsent(bizTag, k -> new SegmentBuffer(bizTag));return buffer.nextId();}/*** 内部号段缓冲区类，实现双Buffer机制*/private class SegmentBuffer {private String bizTag;private Segment[] segments = new Segment[2]; // 双Bufferprivate volatile int currentPos = 0; // 当前使用的segment位置private Lock lock = new ReentrantLock();private volatile boolean isLoadingNext = false; // 是否正在异步加载下一个号段public SegmentBuffer(String bizTag) {this.bizTag = bizTag;segments[0] = new Segment(0, 0);segments[1] = new Segment(0, 0);}/*** 获取下一个ID*/public long nextId() {// 获取当前号段Segment segment = segments[currentPos];// 如果当前号段为空或已用完，切换到另一个号段if (!segment.isInitialized() || segment.getValue() > segment.getMax()) {lock.lock();try {// 双重检查当前号段状态segment = segments[currentPos];if (!segment.isInitialized() || segment.getValue() > segment.getMax()) {// 切换到另一个号段currentPos = (currentPos + 1) % 2;segment = segments[currentPos];// 如果另一个号段也未初始化或已用完，则同步加载if (!segment.isInitialized() || segment.getValue() > segment.getMax()) {loadSegmentFromRedis(segment);}}} finally {lock.unlock();}}// 检查是否需要异步加载下一个号段long value = segment.incrementAndGet();if (value > segment.getMin() + (segment.getMax() - segment.getMin()) * LOAD_FACTOR&& !isLoadingNext) {isLoadingNext = true;// 异步加载下一个号段new Thread(() -> {Segment nextSegment = segments[(currentPos + 1) % 2];loadSegmentFromRedis(nextSegment);isLoadingNext = false;}).start();}return value;}/*** 从Redis加载号段*/private void loadSegmentFromRedis(Segment segment) {String key = SEGMENT_KEY + ":" + bizTag;// 执行Lua脚本获取号段最大值Long max = redisTemplate.execute(segmentScript, Collections.singletonList(key),String.valueOf(SEGMENT_STEP));if (max == null) {throw new RuntimeException("Failed to load segment from Redis");}// 设置号段范围long min = max - SEGMENT_STEP + 1;segment.setMax(max);segment.setMin(min);segment.setValue(min - 1); // 设置为min-1，第一次incrementAndGet返回minsegment.setInitialized(true);}}/*** 内部号段类，存储号段的范围信息*/private class Segment {private long min; // 最小值private long max; // 最大值private AtomicLong value; // 当前值private volatile boolean initialized; // 是否已初始化public Segment(long min, long max) {this.min = min;this.max = max;this.value = new AtomicLong(min);this.initialized = false;}public long getValue() {return value.get();}public void setValue(long value) {this.value.set(value);}public long incrementAndGet() {return value.incrementAndGet();}public long getMin() {return min;}public void setMin(long min) {this.min = min;}public long getMax() {return max;}public void setMax(long max) {this.max = max;}public boolean isInitialized() {return initialized;}public void setInitialized(boolean initialized) {this.initialized = initialized;}}
}

优缺点

优点

  • 双Buffer设计，高可用性
  • 异步加载下一个号段，性能更高
  • 大幅降低Redis访问频率
  • 即使Redis短暂不可用，仍可分配一段时间的ID

缺点

  • 实现复杂，代码量大
  • 多实例部署时，各实例获取的号段不连续
  • 重启服务时号段内的ID可能浪费
  • 需要在内存中维护状态

适用场景

  • 对ID生成可用性要求高的业务
  • 需要高性能且多服务器部署的分布式系统

4. 性能对比与选型建议

策略性能可用性ID长度实现复杂度单调递增
INCR命令★★★☆☆★★☆☆☆递增整数低严格递增
Lua批量生成★★★★★★★★☆☆递增整数中批次内递增
分段式ID★★★★★★★★★☆递增整数高段内递增

5. 实践优化技巧

1. Redis高可用配置

// 配置Redis哨兵模式，提高可用性
@Bean
public RedisConnectionFactory redisConnectionFactory() {RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration().master("mymaster").sentinel("127.0.0.1", 26379).sentinel("127.0.0.1", 26380).sentinel("127.0.0.1", 26381);return new LettuceConnectionFactory(sentinelConfig);
}

2. ID预热策略

// 系统启动时预热ID生成器
@PostConstruct
public void preWarmIdGenerator() {// 预先获取一批ID，确保系统启动后立即可用for (int i = 0; i < 10; i++) {try {segmentIdGenerator.nextId("order");segmentIdGenerator.nextId("user");segmentIdGenerator.nextId("payment");} catch (Exception e) {log.error("Failed to pre-warm ID generator", e);}}
}

3. 降级策略

// Redis不可用时的降级策略
public long nextIdWithFallback(String bizTag) {try {return segmentIdGenerator.nextId(bizTag);} catch (Exception e) {log.warn("Failed to get ID from Redis, using local fallback", e);// 使用本地UUID或其他替代方案return Math.abs(UUID.randomUUID().getMostSignificantBits());}
}

6. 结论

选择合适的分布式ID生成策略时，需要综合考虑系统规模、性能需求、可靠性要求和实现复杂度。无论选择哪种方案，都应注重高可用性设计，增加监控和预警机制，确保ID生成服务的稳定运行。

在实践中，可以基于业务需求对这些方案进行组合和优化，例如为不同业务选择不同策略，或者在ID中嵌入业务标识等，打造更适合自身系统的分布式ID生成解决方案。

http://www.xdnf.cn/news/429.html

相关文章：

  • 多线程——阻塞队列（六）
  • LeetCode（Hot.2）—— 49.字符异位词分组题解
  • ARINC818-实现
  • ueditorplus编辑器已增加AI智能
  • UI键盘操作
  • 计算机网络期中复习笔记（自用）
  • 【技术派后端篇】 Redis 实现用户活跃度排行榜
  • 【UniApp】Vue2 scss 预编译器默认已由 node-sass 更换为 dart-sass
  • 如何优雅地为 Axios 配置失败重试与最大尝试次数
  • PG，TRPO,PPO,GRPO,DPO原理梳理
  • Windows桌面图标变白的解决方案
  • 不连续数据区间天数累计sql
  • Python制作简易PDF查看工具PDFViewerV1.0显示优化
  • HTML5+CSS3小实例：CSS立方体
  • 【Lua语言】Lua语言快速入门
  • redis和lua为什么能实现事务
  • 在STM32的定时器外设中，选择使用哪个外部时钟配置函数
  • 猫咪如厕检测与分类识别系统系列【十二】猫咪进出事件逻辑及日志优化
  • 【sylar-webserver】8 HOOK模块
  • Linux-进度条小程序
  • 【笔记】网路安全管理-实操
  • FiftyOne 管理数据
  • React-useRef
  • 实现Azure Data Factory安全地请求企业内部API返回数据
  • 图灵奖得主LeCun：DeepSeek开源在产品层是一种竞争，但在基础方法层更像是一种合作；新一代AI将情感化
  • Ubuntu20.04下Docker方案实现多平台SDK编译
  • 国网B接口协议图像数据上报通知接口流程详解以及上报失败原因（电网B接口）
  • 【LeetCode 热题 100】双指针 系列
  • 【leetcode100】分割等和子集
  • systemctl管理指令