• 全局唯一ID生成器

    分布式环境中，如何保证生成的id是唯一不重复的？

    twitter，开源出了一个snowflake算法，现在很多企业都按照该算法作为参照，实现了自己的一套id生成器。

    该算法的主要思路为：

    刚好64位的long型数据。

    上图中主要由4个部分组成：

    第一部分，1位为标识位，不用。

    第二部分，41位，用来记录当前时间与标记时间twepoch的毫秒数的差值，41位的时间截，可以使用69年，T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69

    第三部分，10位，用来记录当前节点的信息，支持2的10次方台机器

    第四部分，12位，用来支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号

    java代码

    [java] view plain copy print?
    1. /** 
    2.  * Twitter_Snowflake<br> 
    3.  * SnowFlake的结构如下(每部分用-分开):<br> 
    4.  * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br> 
    5.  * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分) 
    6.  */  
    7. public class SnowflakeIdWorker {  
    8.   
    9.     /** 开始时间截 (2015-01-01) */  
    10.     private final long twepoch = 1420041600000L;  
    11.   
    12.     /** 机器id所占的位数 */  
    13.     private final long workerIdBits = 5L;  
    14.   
    15.     /** 数据标识id所占的位数 */  
    16.     private final long datacenterIdBits = 5L;  
    17.   
    18.     /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */  
    19.     private final long maxWorkerId = -1L ^ (-1L << workerIdBits);  
    20.   
    21.     /** 支持的最大数据标识id，结果是31 */  
    22.     private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);  
    23.   
    24.     /** 序列在id中占的位数 */  
    25.     private final long sequenceBits = 12L;  
    26.   
    27.     /** 机器ID向左移12位 */  
    28.     private final long workerIdShift = sequenceBits;  
    29.   
    30.     /** 数据标识id向左移17位(12+5) */  
    31.     private final long datacenterIdShift = sequenceBits + workerIdBits;  
    32.   
    33.     /** 时间截向左移22位(5+5+12) */  
    34.     private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;  
    35.   
    36.     /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */  
    37.     private final long sequenceMask = -1L ^ (-1L << sequenceBits);  
    38.   
    39.     /** 工作机器ID(0~31) */  
    40.     private long workerId;  
    41.   
    42.     /** 数据中心ID(0~31) */  
    43.     private long datacenterId;  
    44.   
    45.     /** 毫秒内序列(0~4095) */  
    46.     private long sequence = 0L;  
    47.   
    48.     /** 上次生成ID的时间截 */  
    49.     private long lastTimestamp = -1L;  
    50.   
    51.     /** 
    52.      * 构造函数 
    53.      * @param workerId 工作ID (0~31) 
    54.      * @param datacenterId 数据中心ID (0~31) 
    55.      */  
    56.     public SnowflakeIdWorker(long workerId, long datacenterId) {  
    57.         if (workerId > maxWorkerId || workerId < 0) {  
    58.             throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));  
    59.         }  
    60.         if (datacenterId > maxDatacenterId || datacenterId < 0) {  
    61.             throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));  
    62.         }  
    63.         this.workerId = workerId;  
    64.         this.datacenterId = datacenterId;  
    65.     }  
    66.   
    67.     /** 
    68.      * 获得下一个ID (该方法是线程安全的) 
    69.      * @return SnowflakeId 
    70.      */  
    71.     public synchronized long nextId() {  
    72.         long timestamp = timeGen();  
    73.   
    74.         //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常  
    75.         if (timestamp < lastTimestamp) {  
    76.             throw new RuntimeException(  
    77.                     String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));  
    78.         }  
    79.   
    80.         //如果是同一时间生成的，则进行毫秒内序列  
    81.         if (lastTimestamp == timestamp) {  
    82.             sequence = (sequence + 1) & sequenceMask;  
    83.             //毫秒内序列溢出  
    84.             if (sequence == 0) {  
    85.                 //阻塞到下一个毫秒,获得新的时间戳  
    86.                 timestamp = tilNextMillis(lastTimestamp);  
    87.             }  
    88.         }  
    89.         //时间戳改变，毫秒内序列重置  
    90.         else {  
    91.             sequence = 0L;  
    92.         }  
    93.   
    94.         //上次生成ID的时间截  
    95.         lastTimestamp = timestamp;  
    96.   
    97.         //移位并通过或运算拼到一起组成64位的ID  
    98.         return ((timestamp - twepoch) << timestampLeftShift) //  
    99.                 | (datacenterId << datacenterIdShift) //  
    100.                 | (workerId << workerIdShift) //  
    101.                 | sequence;  
    102.     }  
    103.   
    104.     /** 
    105.      * 阻塞到下一个毫秒，直到获得新的时间戳 
    106.      * @param lastTimestamp 上次生成ID的时间截 
    107.      * @return 当前时间戳 
    108.      */  
    109.     protected long tilNextMillis(long lastTimestamp) {  
    110.         long timestamp = timeGen();  
    111.         while (timestamp <= lastTimestamp) {  
    112.             timestamp = timeGen();  
    113.         }  
    114.         return timestamp;  
    115.     }  
    116.   
    117.     /** 
    118.      * 返回以毫秒为单位的当前时间 
    119.      * @return 当前时间(毫秒) 
    120.      */  
    121.     protected long timeGen() {  
    122.         return System.currentTimeMillis();  
    123.     }  
    124. }  
    /**
 * Twitter_Snowflake<br>
 * SnowFlake的结构如下(每部分用-分开):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)
 */
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();
    }
}
  • 相关阅读:
    学期总结
    Sprint 2（第一天）
    学期总结
    实验四、主存空间的分配和回收
    阅读《构建之法》与链接有感.
    《构建之法》八、九、十章读后感
    Scrum领取任务
    实验三、进程调度模拟程序实验
    《构建之法》6-7章读后感
    实验二 作业调度模拟程序
  • 原文地址：https://www.cnblogs.com/firstdream/p/9055771.html
Copyright © 2020-2023  润新知