（Snowflake Algorithm）雪花算法Java的简单使用

概述

雪花算法（Snowflake Algorithm）最初是由Twitter开源的，用于生成一个64位的长整型数字作为全局唯一的ID。这个算法是用Scala语言编写的，并且在Twitter内部得到了广泛应用。由于其简单、高效和分布式友好的特性，雪花算法后来也被其他很多公司和项目采用，并可能被移植到其他编程语言中实现。

其结构如下：

1. 第一位：未使用，因为二进制中最高位是符号位，正数是0，负数是1，一般生成的ID为正数，所以默认为0。
2. 接下来的41位：用来记录时间戳（毫秒）。
3. 接下来的10位：用来记录工作机器ID，包括5位datacenterId和5位workerId。10位的长度最多支持部署在1024个节点（即机器或数据中心）上。
4. 最后的12位：序列号，用来记录同毫秒内产生的不同ID序号，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截并发量)可以产生 4096 个 ID 序号。

雪花算法的优点包括：

1. 毫秒数在高位，生成ID整体上按时间趋势递增；
2. 不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的；
3. 可以根据自身业务特性分配bit位，非常灵活。

然而，雪花算法也有其局限性，比如当数据中心ID或工作机器ID达到上限时，就需要进行扩容或重新规划。此外，如果时钟回拨，可能会导致生成的ID出现冲突或不符合预期的情况，虽然可以通过一些策略进行避免，但仍需注意处理这类情况。

总的来说，雪花算法是一种简单、高效、灵活的分布式ID生成算法，适用于大多数分布式系统场景。但在使用时，需要根据自身业务特性和需求进行合理规划和调整。

基于Java实现的雪花算法工具类

package com.desmond.common.utils;


public class SnowflakeIdWorker {
    /** 开始时间截 (2015-01-01) 可自定义修改 */
    private final long twepoch = 1288834974657L;

    /** 机器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) {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(1, 2);
        for (int i = 0; i < 10; i++) {
            long id = idWorker.nextId();
            System.out.println(id);
        }
    }
}

使用例子

Java框架为SpringBoot

在雪花算法中，机器ID（workerID）和数据中心ID（datacenterID）是确保生成的ID全局唯一性的两个关键参数。

机器ID主要用于标识分布式系统中的不同工作机器。每个工作节点需要分配一个唯一的workerID，以确保在同一个数据中心下的不同工作节点之间生成的ID不会重复。通过这种方式，雪花算法可以确保即使在高度分布式的环境中，也能生成唯一的ID。

数据中心ID则用于标识不同的数据中心。在分布式系统中，可能有多个数据中心在运行，每个数据中心都可能有多个工作机器。通过为每个数据中心分配一个唯一的datacenterID，雪花算法可以确保在多个数据中心之间生成的ID也不会重复。

这两个参数的具体值通常是根据实际部署环境来设定的。例如，机房号、机器号、服务号或其他可区别标识的比特位整数值都可以被用作这两个参数的设定依据。

总的来说，机器ID和数据中心ID是雪花算法实现全局唯一ID生成的重要组成部分，它们共同确保了即使在复杂的分布式环境中，也能生成唯一且有序的ID。

# yml配置工作id 和 数据中心id

SnowflakeId:
  workerId: 1
  dataCenterId: 1

    @Value("${SnowflakeId.workerId}")
    private Integer WORKER_ID;
    @Value("${SnowflakeId.dataCenterId}")
    private Integer DATACENTER_ID;

    public String GetSystemserialnumber() {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(WORKER_ID, DATACENTER_ID);
        long SnowflakeId = idWorker.nextId();
        //返回的字符串示例：TEST1784571656338149378
        return "TEST" + SnowflakeId;
    }