分布式ID生成算法深度对比：Snowflake、阿里改良版及竞品分析

已于 2025-03-30 12:19:31 修改
阅读量829 收藏 23
点赞数 18
文章标签： 分布式 系统架构 算法 java
于 2025-03-30 12:08:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/freakwiko/article/details/146739973
版权

背景

在分布式系统中，生成唯一且有序的ID是一个常见的需求。ID生成算法需要满足以下核心要求：

  • 唯一性：确保全局唯一，避免ID冲突。
  • 有序性：ID生成顺序尽可能单调递增。
  • 高性能：支持高并发场景，生成ID的速度要快。
  • 低延迟：在分布式系统中，ID生成的延迟要尽可能低。
  • 扩展性：支持系统规模的扩展。

本文将详细对比分析以下几种分布式ID生成算法：

  1. 雪花算法（Snowflake）
  2. 阿里巴巴改良版雪花算法
  3. UUID
  4. 时间戳+随机数
  5. 数据库自增主键
  6. Redis的INCR/INCRBY命令
  7. 基于一致性哈希的算法

目录

1. 雪花算法（Snowflake）

基本原理

实现逻辑

Java实现

优缺点

适用场景

2. 阿里巴巴改良版雪花算法

基本原理

实现逻辑

Java实现

优缺点

适用场景

3. UUID

基本原理

实现逻辑

Java实现

优缺点

适用场景

4. 时间戳+随机数

基本原理

实现逻辑

Java实现

优缺点

适用场景

5. 数据库自增主键

基本原理

实现逻辑

Java实现

优缺点

适用场景

6. Redis的INCR/INCRBY命令

基本原理

实现逻辑

Java实现

优缺点

适用场景

7. 基于一致性哈希的算法

基本原理

实现逻辑

Java实现

优缺点

适用场景

8. 汇总比对

9. 总结

1. 雪花算法（Snowflake）

基本原理

雪花算法是Twitter开源的一种分布式ID生成算法，其生成的ID是一个64位的长整型数字。ID的结构如下：

  • 时间戳（41位）：记录生成ID的时间，精确到毫秒。
  • 机器ID（10位）：用于标识不同的机器节点。
  • 序列号（12位）：同一毫秒内生成的ID的序列号，确保同一机器节点内的ID唯一。

实现逻辑

  1. 获取当前时间戳（精确到毫秒）。
  2. 计算时间戳差值（与基准时间戳的差值）。
  3. 结合机器ID和序列号生成最终的ID。
Java实现
public class SnowflakeIdGenerator {
    private final long workerId;
    private final long dataCenterId;
    private long sequence = 0L;
    private final long sequenceMask = -1L ^ (-1L << 12); // 12位序列号
    private final long workerMask = -1L ^ (-1L << 10);   // 10位机器ID
    private long lastTimestamp = -1L;

    public SnowflakeIdGenerator(long workerId, long dataCenterId) {
        if (workerId > workerMask || workerId < 0) {
            throw new IllegalArgumentException("workerId can't be greater than 1023");
        }
        if (dataCenterId > workerMask || dataCenterId < 0) {
            throw new IllegalArgumentException("dataCenterId can't be greater than 1023");
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards. Refusing to generate id");
        }
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        return ((timestamp - 1288834974657L) << 22) | (dataCenterId << 12) | (workerId << 12) | sequence;
    }

    private long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) {
        SnowflakeIdGenerator generator = new SnowflakeIdGenerator(1, 1);
        for (int i = 0; i < 10; i++) {
            System.out.println(generator.nextId());
        }
    }
}

优缺点

  • 优点： 
    • 生成ID有序，支持全局唯一。
    • 时间戳作为主要部分，支持排序。
    • 高性能，支持高并发场景。
  • 缺点： 
    • 对时间精度依赖较高，若机器时间被修改，可能导致ID冲突。
    • 机器ID和数据中心ID需要手动配置。

适用场景

  • 需要全局唯一且有序的ID场景，如订单ID、消息ID等。

2. 阿里巴巴改良版雪花算法

基本原理

阿里巴巴在雪花算法的基础上进行了改良，主要改进点如下：

  • 支持多机房部署：增加机房ID字段，避免不同机房之间的ID冲突。
  • 支持时间回拨：通过记录上次生成ID的时间戳，避免时间回拨导致的ID冲突。
  • 优化序列号生成：采用更高效的序列号生成方式。

实现逻辑

  1. 获取当前时间戳。
  2. 计算时间戳差值。
  3. 结合机器ID、机房ID和序列号生成最终的ID。
Java实现
public class AlibabaSnowflakeIdGenerator {
    private final long workerId;
    private final long dataCenterId;
    private long sequence = 0L;
    private final long sequenceMask = -1L ^ (-1L << 12); // 12位序列号
    private final long workerMask = -1L ^ (-1L << 10);   // 10位机器ID
    private long lastTimestamp = -1L;

    public AlibabaSnowflakeIdGenerator(long workerId, long dataCenterId) {
        if (workerId > workerMask || workerId < 0) {
            throw new IllegalArgumentException("workerId can't be greater than 1023");
        }
        if (dataCenterId > workerMask || dataCenterId < 0) {
            throw new IllegalArgumentException("dataCenterId can't be greater than 1023");
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards. Refusing to generate id");
        }
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;
        return ((timestamp - 1288834974657L) << 22) | (dataCenterId << 12) | (workerId << 12) | sequence;
    }

    private long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) {
        AlibabaSnowflakeIdGenerator generator = new AlibabaSnowflakeIdGenerator(1, 1);
        for (int i = 0; i < 10; i++) {
            System.out.println(generator.nextId());
        }
    }
}

优缺点

  • 优点： 
    • 支持多机房部署，避免ID冲突。
    • 时间回拨处理更完善。
    • 生成ID有序且唯一。
  • 缺点： 
    • 配置复杂，需要手动设置机器ID和机房ID。
    • 对时间精度依赖较高。

适用场景

  • 多机房部署的分布式系统，需要全局唯一且有序的ID。

3. UUID

基本原理

UUID（Universally Unique Identifier）是一种128位的唯一标识符，通常由时间戳、随机数和机器标识符组成。UUID的生成方式有多种，常见的有基于时间的UUID（Version 1）和基于随机数的UUID（Version 4）。

实现逻辑

  1. 生成时间戳。
  2. 生成随机数。
  3. 结合机器标识符生成最终的UUID。
Java实现
import java.util.UUID;

public class UUIDGenerator {
    public static String generateUUID() {
        return UUID.randomUUID().toString();
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(generateUUID());
        }
    }
}

优缺点

  • 优点： 
    • 全局唯一性保证。
    • 无需依赖外部系统。
  • 缺点： 
    • 存储和传输成本高（128位）。
    • 无序性，无法按时间排序。

适用场景

  • 需要全局唯一性但对顺序无要求的场景，如用户ID、文档ID等。

4. 时间戳+随机数

基本原理

时间戳+随机数是一种简单的分布式ID生成方式，通常由时间戳和随机数拼接而成。

实现逻辑

  1. 获取当前时间戳。
  2. 生成随机数。
  3. 拼接时间戳和随机数生成最终的ID。
Java实现
import java.util.Random;

public class TimestampRandomIdGenerator {
    private static final Random RANDOM = new Random();
    private static final long START_TIMESTAMP = 1640995200000L; // 2022-01-01 00:00:00

    public long generateId() {
        long timestamp = System.currentTimeMillis() - START_TIMESTAMP;
        int random = RANDOM.nextInt(9999);
        return timestamp * 10000 + random;
    }

    public static void main(String[] args) {
        TimestampRandomIdGenerator generator = new TimestampRandomIdGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(generator.generateId());
        }
    }
}

优缺点

  • 优点： 
    • 实现简单。
    • 时间戳部分保证了ID的有序性。
  • 缺点： 
    • 随机数部分可能导致ID冲突。
    • 性能较低，不适合高并发场景。

适用场景

  • 对ID有序性和唯一性要求不高的场景。

5. 数据库自增主键

基本原理

数据库自增主键是通过数据库的自增字段（如MySQL的AUTO_INCREMENT）生成ID。每次插入新记录时，数据库会自动分配一个唯一的ID。

实现逻辑

  1. 插入新记录时，数据库自动生成ID。
Java实现
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DatabaseIdGenerator {
    public long generateId() throws Exception {
        String url = "jdbc:mysql://localhost:3306/test";
        String  = "root";
        String password = "password";
        Connection conn = DriverManager.getConnection(url, , password);
        try {
            String sql = "INSERT INTO  (name) VALUES (?)";
            PreparedStatement pstmt = conn.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
            pstmt.setString(1, "test");
            pstmt.executeUpdate();
            ResultSet rs = pstmt.getGeneratedKeys();
            if (rs.next()) {
                return rs.getLong(1);
            }
            return -1;
        } finally {
            conn.close();
        }
    }

    public static void main(String[] args) throws Exception {
        DatabaseIdGenerator generator = new DatabaseIdGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(generator.generateId());
        }
    }
}

优缺点

  • 优点： 
    • 实现简单，无需额外开发。
    • 数据库保证唯一性。
  • 缺点： 
    • 性能受限于数据库，不适合高并发场景。
    • 增加了数据库的负担。

适用场景

  • 系统规模较小，对性能要求不高的场景。

6. Redis的INCR/INCRBY命令

基本原理

Redis的INCR/INCRBY命令可以用来生成全局唯一的递增ID。通过Redis的原子操作，可以保证ID的唯一性和有序性。

实现逻辑

  1. 使用Redis的INCR命令生成递增ID。
Java实现
import redis.clients.jedis.Jedis;

public class RedisIdGenerator {
    public long generateId() {
        Jedis jedis = new Jedis("localhost");
        try {
            return jedis.incr("id_counter");
        } finally {
            jedis.close();
        }
    }

    public static void main(String[] args) {
        RedisIdGenerator generator = new RedisIdGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(generator.generateId());
        }
    }
}

优缺点

  • 优点： 
    • 高性能，支持高并发场景。
    • Redis保证ID的唯一性和有序性。
  • 缺点： 
    • 依赖Redis，增加了系统的复杂性。
    • 如果Redis发生故障，可能会影响ID生成。

适用场景

  • 需要全局唯一且有序的ID，且系统中已经使用Redis的场景。

7. 基于一致性哈希的算法

基本原理

一致性哈希是一种分布式哈希表算法，可以通过将节点映射到一个环上来实现负载均衡。通过一致性哈希，可以将ID生成任务分摊到不同的节点上。

实现逻辑

  1. 初始化节点及其范围。
  2. 选择当前节点。
  3. 生成ID并返回。
  4. 更新当前节点。
Java实现
import java.util.HashMap;
import java.util.Map;

public class ConsistentHashingIdGenerator {
    private Map<String, Long> nodeRanges = new HashMap<>();
    private String currentNode;

    public void addNode(String nodeName, long range) {
        nodeRanges.put(nodeName, range);
    }

    public long generateId() {
        // 选择当前节点
        currentNode = selectNode();
        // 生成ID
        return System.currentTimeMillis();
    }

    private String selectNode() {
        // 实际实现中需要根据负载均衡算法选择节点
        return "node1";
    }

    public static void main(String[] args) {
        ConsistentHashingIdGenerator generator = new ConsistentHashingIdGenerator();
        generator.addNode("node1", 1000L);
        generator.addNode("node2", 2000L);
        for (int i = 0; i < 10; i++) {
            System.out.println(generator.generateId());
        }
    }
}

优缺点

  • 优点： 
    • 支持负载均衡，节点可以动态加入和退出。
    • 生成ID的性能较高。
  • 缺点： 
    • 实现复杂，需要维护节点状态。
    • 对网络延迟敏感。

适用场景

  • 大规模分布式系统，需要高可用性和负载均衡的场景。

8. 汇总比对

算法名称唯一性有序性性能实现复杂度适用场景
雪花算法高高高中全局唯一且有序的场景
阿里巴巴改良版雪花算法高高高高多机房部署的场景
UUID高低低低全局唯一但无序的场景
时间戳+随机数中中低低对有序性和唯一性要求不高的场景
数据库自增主键高高低低系统规模较小的场景
Redis的INCR/INCRBY命令高高高中系统中使用Redis的场景
基于一致性哈希的算法高中高高大规模分布式系统的场景

9. 总结

在选择分布式ID生成算法时，需要根据具体的业务需求、系统规模和性能要求进行权衡：

  • 如果需要全局唯一且有序的ID，推荐使用雪花算法或阿里巴巴改良版雪花算法。
  • 如果对性能要求较高且系统中已经使用Redis，可以考虑使用Redis的INCR/INCRBY命令。
  • 如果需要全局唯一但对顺序无要求，可以使用UUID。
  • 如果系统规模较小，可以使用数据库自增主键。
brave java
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值