Java分布式ID

1 什么是分布式ID

分布式ID是指在分布式系统中生成的唯一标识符，用于标识不同实体或数据的唯一性。在分布式系统中，多台机器并行处理任务，为了确保生成的ID在整个系统中的唯一性，需要采用特殊的算法来生成分布式ID。

在传统的单机系统中，可以使用自增序列或随机数来生成唯一ID。但在分布式系统中，多台机器同时生成ID时可能会导致重复的情况。为了解决这个问题，需要引入一种分布式ID生成算法，确保在整个分布式系统中生成的ID是唯一的。

分布式ID的设计要考虑并发性能、全局唯一性和扩展性等因素，并根据具体的系统需求选择合适的算法实现。常见的分布式ID生成算法包括雪花算法（Snowflake）、UUID（Universally Unique Identifier）等。

2 UUID

UUID（Universally Unique Identifier）是一种标识符，用于在计算系统中生成全局唯一的ID。它是由128位的二进制数表示，通常以32位的十六进制字符串形式展示。

UUID的生成算法保证了在全球范围内生成的ID具有极高的唯一性。它不依赖于中央控制器或集中式的ID生成服务，可以在分布式系统中生成唯一的标识符。

生成的UUID通常呈现为以下形式：

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx

其中，"x"表示十六进制数字。具体的格式和含义取决于UUID的版本和变体。

UUID具有以下特点：

全局唯一性：UUID的生成算法确保在全球范围内生成的ID具有极高的唯一性，不同系统和节点生成的UUID几乎不会重复。
无序性：UUID是基于随机数或名称空间生成的，没有严格的递增或递减顺序。
可用性：UUID生成算法简单高效，生成过程不需要依赖网络通信或中央服务器。

UUID广泛应用于分布式系统、数据库、标识符生成等场景，用于唯一标识实体、数据记录或资源。它在保证全局唯一性的同时，提供了一种简单可靠的标识方案。

在Java中，UUID类是用于生成和操作UUID的工具类，提供了方便的方法来生成和操作UUID。它可以用于在Java应用程序中生成唯一的标识符，例如在分布式系统中跟踪实体或记录的唯一标识。

UUID类位于java.util包下，并提供了以下主要方法：

randomUUID(): 静态方法，用于生成一个随机的UUID。该方法会使用随机数生成算法生成一个符合UUID标准的随机UUID。
toString(): 将UUID对象转换为字符串表示。

使用java生产一个UUID的代码示意如下：

UUID uuid = UUID.randomUUID();
String uuidString = uuid.toString();

UUID的优势与劣势

优势：

全局唯一性：UUID的生成算法保证了生成的ID在全球范围内的唯一性，不依赖于中央控制器或集中式的ID生成服务。这意味着在分布式系统中不同节点生成的UUID不会发生冲突。
无序性：UUID是基于随机数生成的，没有严格的递增或递减的顺序。这对于某些应用场景来说是有利的，因为它不会暴露数据生成的时间或其他敏感信息。
简单易用：UUID的生成算法相对简单，生成过程高效，可以快速地生成ID。
无需网络通信：生成UUID不需要依赖网络通信或中央服务器，每个节点可以独立生成ID，减少了系统的复杂性和对网络的依赖。

劣势：

长度较长：UUID通常由32位的十六进制数表示，加上分隔符的话长度更长。这会增加存储和传输的成本，特别是在大规模的数据集合中使用UUID作为标识符时。
不可读性：UUID是由数字和字母组成的字符串，对人类来说不太友好，不易于直观理解。这在调试、日志记录和数据查询等场景中可能会带来一些困难。
无法排序：由于UUID是基于随机数生成的，它们之间没有严格的顺序关系。这导致在某些需要按照时间或顺序访问数据的场景中，UUID并不适合作为排序依据。
不适合作为数据库索引：由于UUID的无序性和长度较长，将UUID作为数据库的主键或索引可能会导致性能下降，尤其是在大规模数据集合和频繁的索引操作中。

3 雪花算法

雪花算法（Snowflake Algorithm）是一种常用的分布式ID生成算法，最初由Twitter开发并广泛应用于分布式系统中。它的设计目标是生成全局唯一且有序递增的ID，适用于大规模分布式系统中的标识符需求。相对于UUID，雪花算法ID的好处是长度短并且还是有序递增的。

雪花算法生成的ID是一个64位的长整型数值，具体格式如下所示：

0 | 0000000000 | 00000 | 00000 | 000000000000

其中：最高位是未使用的符号位（为0），接下来的41位表示时间戳，然后是5位的数据中心标识符，5位的机器标识符，最后是12位的序列号。

雪花算法生成ID的过程如下：

时间戳：使用当前时间戳减去一个固定的起始时间（如2010年1月1日），得到一个相对时间。这样可以确保在一定时间内生成的ID具有递增的趋势。
数据中心标识符和机器标识符：每个数据中心分配一个唯一的数据中心标识符，每台机器分配一个唯一的机器标识符。这样可以在分布式环境中唯一标识每个数据中心和每台机器。
序列号：在同一毫秒内生成的ID，通过序列号来进行区分，保证同一机器在同一毫秒内生成的ID的唯一性。序列号从0开始，每生成一个ID自增1，最多可以达到12位的长度（即4096个序列号）。

雪花算法的优点包括：

全局唯一性：在分布式系统中，不同节点生成的ID不会产生冲突，确保全局唯一性。
有序性：生成的ID在时间上有序递增，方便按照时间排序和索引。
高性能：生成ID的算法简单高效，不依赖于网络通信或中央服务器。

然而，雪花算法也有一些限制：

依赖于系统时间：由于使用时间戳作为ID的一部分，系统时间的回拨或不同节点之间的时间差异可能会导致生成的ID不唯一或不按照预期顺序递增。
数据中心和机器标识符的分配需要管理：为每个数据中心和机器分配唯一标识符需要一定的管理工作，确保标识符的唯一性。
时钟回拨问题：如果系统时间发生回拨（校准调整时间），可能会导致生成的ID不唯一或不按照预期递增。

在使用雪花算法时，需要根据具体应用的需求和场景，合理设置数据。

/**
 * 雪花算法
 */
public class SnowFlake {

    /** 开始时间截 (2020-01-01) */
    private final long twepoch = 1577808000000L;

    /** 机器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;

    private static SnowFlake idWorker;

    static {
        idWorker = new SnowFlake(getWorkId(),getDataCenterId());
    }

    //==============================Constructors=====================================
    /**
     * 构造函数
     * @param workerId 工作ID (0~31)
     * @param dataCenterId 数据中心ID (0~31)
     */
    public SnowFlake(long workerId, long dataCenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("workerId can't be greater than %d or less than 0", maxWorkerId));
        }
        if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
            throw new IllegalArgumentException(String.format("dataCenterId can't be greater than %d or less than 0", maxDataCenterId));
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }

    // =====================Methods=======================
    /**
     * 获得下一个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();
    }

    private static Long getWorkId(){
        try {
            String hostAddress = Inet4Address.getLocalHost().getHostAddress();
            int[] ints = StringUtils.toCodePoints(hostAddress);
            int sums = 0;
            for(int b : ints){
                sums += b;
            }
            return (long)(sums % 32);
        } catch (UnknownHostException e) {
            // 如果获取失败，则使用随机数备用
            return RandomUtils.nextLong(0,31);
        }
    }

    private static Long getDataCenterId(){
        int[] ints = StringUtils.toCodePoints(StringUtils.isEmpty(SystemUtils.getHostName())?"defaultvalue":SystemUtils.getHostName());
        int sums = 0;
        for (int i: ints) {
            sums += i;
        }
        return (long)(sums % 32);
    }


    /**
     * 静态工具类
     *
     * @return
     */
    public static Long generateId(){
        long id = idWorker.nextId();
        return id;
    }

    //==================Test===================
    /** 测试 */
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());
        long startTime = System.nanoTime();
        for (int i = 0; i < 50000; i++) {
            long id = SnowFlake.generateId();
            System.out.println(id);
        }
        System.out.println((System.nanoTime()-startTime)/1000000+"ms");
    }

}

使用上述的雪花算法实现，调用 SnowFlake.generateId() 方法来生成唯一的ID。确保为每个实例分配唯一的数据中心ID和机器ID。

这样，你就能够在童小码项目中生成分布式有序的商品、课程等业务关键字的ID，同时保持高性能和全局唯一性。