认识雪花算法_雪花id-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_63197684/article/details/144949893

雪花算法（Snowflake Algorithm）是由 Twitter 开发的分布式 ID 生成算法，它能够在分布式系统中生成唯一且高效的 ID。雪花算法通过将一个 64 位的长整型数字（long）划分为不同的部分，其中每一部分都有明确的含义，从而保证了 ID 的唯一性和排序性。

雪花算法的结构

一个生成的 Snowflake ID 是一个 64 位的二进制数。雪花算法通常将这 64 位分为以下几个部分：

1位符号位	41位时间戳	10位机器ID	12位序列号
0	时间戳（毫秒级）	工作机器ID	毫秒内自增序列号

各部分的具体含义

符号位（1 bit）：
- 最高位（符号位）为 0，表示正数，始终为 0，不影响 ID 的大小。
时间戳（41 bits）：
- 用来表示毫秒级别的时间戳，41 位可以表示 2^41 毫秒，即大约 69 年（具体的时间范围取决于起始时间戳）。
- 为了避免时间戳的冲突，通常会指定一个自定义的起始时间戳（通常是某个固定时间，如 2020 年 1 月 1 日）。
机器 ID（10 bits）：
- 10 位的机器 ID 用来标识不同的工作节点。理论上可以支持最多 1024 个节点（2^10 = 1024）。这部分通常包含数据中心 ID 和机器 ID，用于分布式系统中区分不同的机器。
序列号（12 bits）：
- 用于在同一毫秒内生成多个不同的 ID。12 位的序列号最多支持在同一毫秒内生成 4096 个不同的 ID（2^12 = 4096）。每当生成一个新的 ID 时，序列号会递增，直到 4096 为止。如果在同一毫秒内生成超过 4096 个 ID，则会等待下一毫秒。

雪花算法的 ID 生成流程

时间戳：生成的 ID 中包含当前时间戳。算法会获取当前的系统时间（通常以毫秒为单位），并与自定义的起始时间戳进行比较，计算出距离起始时间戳的毫秒数。
机器 ID：每个机器上会有一个唯一的标识符（例如，数据中心 ID 和机器 ID 的组合），它保证了分布式环境中不同节点生成的 ID 是唯一的。
序列号：每台机器每毫秒内生成的 ID 是唯一的，它依赖于一个递增的序列号。若在同一毫秒内请求生成多个 ID，序列号将递增，直到达到最大值（即 4095）。如果超过了这个最大值，则会等待下一毫秒。

雪花算法的 ID 结构示意

假设使用 64 位来表示 ID，可以将这 64 位按如下方式划分：

1位符号位	41位时间戳	10位机器ID	12位序列号
0	41 bits	10 bits	12 bits

雪花算法的优点

高效性：
- ID 的生成速度非常快，可以单台机器每秒生成成千上万的 ID。
唯一性：
- 由于算法的设计，ID 可以保证全局唯一性，无论是单台机器还是分布式环境中生成的 ID 都不会冲突。
排序性：
- 生成的 ID 是根据时间戳来排序的，因此生成的 ID 在数值上是有序的。这对于某些需要根据 ID 进行排序的场景（比如数据库中的主键）非常有用。
分布式支持：
- 雪花算法支持分布式部署，可以通过机器 ID 区分不同的机器，保证全局唯一性。

雪花算法的缺点

时钟回拨问题：
- 雪花算法依赖于时间戳，如果系统的时钟回拨（例如，系统时间调整），会导致生成的 ID 不唯一。为了防止这种情况，通常需要加上一些额外的时间回调处理机制。
ID 长度固定：
- 雪花算法生成的 ID 长度是固定的 64 位。如果某些场景需要不同长度的 ID，这可能是一个问题。
节点 ID 配置：
- 雪花算法需要事先为每个节点分配一个唯一的机器 ID，如果节点数量发生变化，需要重新配置。

Java代码示例

public class SnowflakeIdGenerator {
    private final long epoch = 1609459200000L; // 自定义的起始时间戳，2021-01-01 00:00:00
    private final long workerIdBits = 10L;     // 机器ID的位数
    private final long sequenceBits = 12L;     // 序列号的位数
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits); // 最大的机器ID
    private final long sequenceMask = -1L ^ (-1L << sequenceBits); // 最大的序列号

    private long workerId;                     // 机器ID
    private long sequence = 0L;                // 序列号
    private long lastTimestamp = -1L;          // 上次生成ID的时间戳

    public SnowflakeIdGenerator(long workerId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException("workerId can't be greater than " + maxWorkerId + " or less than 0");
        }
        this.workerId = workerId;
    }

    public synchronized long generateId() {
        long timestamp = System.currentTimeMillis();

        // 如果时钟回拨，抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards. Refusing to generate ID");
        }

        // 如果在同一毫秒内，则增加序列号
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 序列号溢出，等待下一毫秒
                timestamp = waitNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        // 计算生成的ID
        long id = ((timestamp - epoch) << (workerIdBits + sequenceBits)) // 时间戳部分
                | (workerId << sequenceBits)                             // 机器ID部分
                | sequence;                                             // 序列号部分
        return id;
    }

    // 等待下一毫秒
    private long waitNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }

    public static void main(String[] args) {
        SnowflakeIdGenerator generator = new SnowflakeIdGenerator(1);  // 机器ID为1
        long id = generator.generateId();
        System.out.println("Generated ID: " + id);
    }
}