雪花算法

2024-10-01

字数统计: 1.6k字 | 阅读时长: 6分

前言

用于生成全局唯一ID（分布式ID）的算法有多种，雪花算法（SnowFlake）是其中一个经典的常用算法。

分布式ID

分布式ID的特点：

全局唯一性：不能出现有重复的ID标识，这是基本要求。
递增性：确保生成ID对于用户或业务是递增的。
高可用性：确保任何时候都能生成正确的ID。
高性能性：在高并发的环境下依然表现良好。

分布式ID的应用场景包括但不限于：

分布式数据库：生成唯一主键。
消息队列：标识消息的唯一性。
用户注册：为新用户生成唯一标识。

雪花算法

SnowFlake最初是Twitter公司采用的一种算法，目的是在分布式系统中产生全局唯一且递增的ID。每一个雪花算法产生的ID都是一个的64bit的long类型的唯一ID。

结构组成

0 -- 41位时间戳 -- 10位机器ID -- 12位序列号

最高1位是符号位，固定为0，表示id是正整数；
接下来41位存储毫秒级时间戳，表示从一个特定时间点（通常是 Unix 纪元时间）开始的毫秒数。这允许生成的 ID 持续大约 69 年，即 $2^{41} / (1000 60 60 * 24 \times 365) = 69$。
再接下10位存储机器码，包括高5位的datacenterId和低5位的workerId。最多可以部署$2^{10}=1024$台机器。
最后12位存储序列号，即在同一毫秒内生成的序列号，允许每个节点在同一毫秒内生成最多 4096 个 ID（$2^{12}$）。

基于组成可以计算雪花算法在同一毫秒内最多可以生成的全局唯一ID数量为$1024 \times 4096 = 4194304$个。

生成过程

生成一个雪花 ID 的过程如下：

获取当前时间戳：计算当前的毫秒时间戳。
检查时间戳是否回拨：如果当前时间小于上次生成 ID 的时间，说明时间回拨，可能会抛出异常或等待。
生成序列号：如果当前时间与上次生成 ID 的时间相同且还有序列号可用，则序列号加1；否则阻塞至下一毫秒。
拼接 ID：将时间戳、机器 ID 和序列号拼接成一个 64 位的整数。

Java实现：

public class SnowflakeIdWorker {
    /**
     * 开始时间截 (2015-01-01)
     */
    private final long twepoch = 1420041600000L;
    /**
     * 机器id所占的位数
     */
    private final long workerIdBits = 5L;
    /**
     * 数据标识id所占的位数
     */
    private final long datacenterIdBits = 5L;
    /**
     * 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
     */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    /**
     * 支持的最大数据标识id，结果是31
     */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    /**
     * 序列在id中占的位数
     */
    private final long sequenceBits = 12L;
    /**
     * 机器ID向左移12位
     */
    private final long workerIdShift = sequenceBits;
    /**
     * 数据标识id向左移17位(12+5)
     */
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    /**
     * 时间截向左移22位(5+5+12)
     */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    /**
     * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
     */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    /**
     * 工作机器ID(0~31)
     */
    private long workerId;
    /**
     * 数据中心ID(0~31)
     */
    private long datacenterId;
    /**
     * 毫秒内序列(0~4095)
     */
    private long sequence = 0L;
    /**
     * 上次生成ID的时间截
     */
    private long lastTimestamp = -1L;
    /**
     * 构造函数
     * @param workerId     工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowflakeIdWorker(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
    /**
     * 获得下一个ID (该方法是线程安全的)
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
        // 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(
                    String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
        // 如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            // 毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        // 时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }
        // 上次生成ID的时间截
        lastTimestamp = timestamp;
        // 移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }
    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }
    /**
     * 返回以毫秒为单位的当前时间
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) throws InterruptedException {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 10; i++) {
            long id = idWorker.nextId();
            Thread.sleep(1);
            System.out.println(id);
        }
    }
}

优缺点分析

优点：
- 高并发：可以在分布式环境下高效生成唯一ID，支持高并发。
- 有序性：生成的ID基于时间戳，具有一定的有序性，适合用于数据库的主键。
- 低延迟：生成ID的速度快，通常在毫秒级别。
缺点
- 时间回拨问题：如果服务器时间发生回拨，可能导致生成重复的ID，需要处理。
- 机器 ID 管理：需要确保机器 ID 的唯一性，管理较为复杂。
- 存储问题：ID 的长度较长（64 位），可能在某些系统中造成存储开销。

部分开源的雪花算法实现

HuTool
百度UidGenerator
美团Leaf

各家对于时钟回拨都有不同的处理，以HuTool为例：

如果时钟回拨不超过2秒，则会将现在的时间点置为上个产生id的时间点（超过2s就抛出异常了）；
如果上个时间点产生的id没有达到4095（超过4095就抛出异常了），即使产生了时钟回拨，也可以继续生成id。
如果出现时钟回拨，假设是5s，那么如果这5s内没有id需要生成，那么时钟回拨没有任何影响。

参考文献

[1] https://github.com/twitter-archive/snowflake/releases/tag/snowflake-2010
[2] https://zhuanlan.zhihu.com/p/85837641
[3] https://blog.csdn.net/weixin_43024834/article/details/135039159

后记

首发于 silencezheng.top，转载请注明出处。