• 【最详细demo】雪花算法详细解释

    简介
    现在的服务基本是分布式、微服务形式的，而且大数据量也导致分库分表的产生，对于水平分表就需要保证表中 id 的全局唯一性。

    对于 MySQL 而言，一个表中的主键 id 一般使用自增的方式，但是如果进行水平分表之后，多个表中会生成重复的 id 值。那么如何保证水平分表后的多张表中的 id 是全局唯一性的呢？

    如果还是借助数据库主键自增的形式，那么可以让不同表初始化一个不同的初始值，然后按指定的步长进行自增。例如有3张拆分表，初始主键值为1，2，3，自增步长为3。

    当然也有人使用 UUID 来作为主键，但是 UUID 生成的是一个无序的字符串，对于 MySQL 推荐使用增长的数值类型值作为主键来说不适合。

    也可以使用 Redis 的自增原子性来生成唯一 id，但是这种方式业内比较少用。

    当然还有其他解决方案，不同互联网公司也有自己内部的实现方案。雪花算法是其中一个用于解决分布式 id 的高效方案，也是许多互联网公司在推荐使用的。

    SnowFlake 雪花算法
    SnowFlake 中文意思为雪花，故称为雪花算法。最早是 Twitter 公司在其内部用于分布式环境下生成唯一 ID。在2014年开源 scala 语言版本。

     

    雪花算法的原理就是生成一个的 64 位比特位的 long 类型的唯一 id。

    最高 1 位固定值 0，因为生成的 id 是正整数，如果是 1 就是负数了。
    接下来 41 位存储毫秒级时间戳，2^41/(1000*60*60*24*365)=69，大概可以使用 69 年。
    再接下 10 位存储机器码，包括 5 位 datacenterId 和 5 位 workerId。最多可以部署 2^10=1024 台机器。
    最后 12 位存储序列号。同一毫秒时间戳时，通过这个递增的序列号来区分。即对于同一台机器而言，同一毫秒时间戳下，可以生成 2^12=4096 个不重复 id。
    可以将雪花算法作为一个单独的服务进行部署，然后需要全局唯一 id 的系统，请求雪花算法服务获取 id 即可。

    对于每一个雪花算法服务，需要先指定 10 位的机器码，这个根据自身业务进行设定即可。例如机房号+机器号，机器号+服务号，或者是其他可区别标识的 10 位比特位的整数值都行。

    算法实现

    1. package util;
    2.  
    3. import java.util.Date;
    4.  
    5. /**
    6.  * @ClassName: SnowFlakeUtil
    7.  * @Author: jiaoxian
    8.  * @Date: 2022/4/24 16:34
    9.  * @Description:
    10.  */
    11. public class SnowFlakeUtil {
    12.  
    13.     private static SnowFlakeUtil snowFlakeUtil;
    14.     static {
    15.         snowFlakeUtil = new SnowFlakeUtil();
    16.     }
    17.  
    18.     // 初始时间戳(纪年)，可用雪花算法服务上线时间戳的值
    19.     // 1650789964886：2022-04-24 16:45:59
    20.     private static final long INIT_EPOCH = 1650789964886L;
    21.  
    22.     // 时间位取&
    23.     private static final long TIME_BIT = 0b1111111111111111111111111111111111111111110000000000000000000000L;
    24.  
    25.     // 记录最后使用的毫秒时间戳，主要用于判断是否同一毫秒，以及用于服务器时钟回拨判断
    26.     private long lastTimeMillis = -1L;
    27.  
    28.     // dataCenterId占用的位数
    29.     private static final long DATA_CENTER_ID_BITS = 5L;
    30.  
    31.     // dataCenterId占用5个比特位，最大值31
    32.     // 0000000000000000000000000000000000000000000000000000000000011111
    33.     private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
    34.  
    35.     // dataCenterId
    36.     private long dataCenterId;
    37.  
    38.     // workId占用的位数
    39.     private static final long WORKER_ID_BITS = 5L;
    40.  
    41.     // workId占用5个比特位，最大值31
    42.     // 0000000000000000000000000000000000000000000000000000000000011111
    43.     private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
    44.  
    45.     // workId
    46.     private long workerId;
    47.  
    48.     // 最后12位，代表每毫秒内可产生最大序列号，即 2^12 - 1 = 4095
    49.     private static final long SEQUENCE_BITS = 12L;
    50.  
    51.     // 掩码（最低12位为1，高位都为0），主要用于与自增后的序列号进行位与，如果值为0，则代表自增后的序列号超过了4095
    52.     // 0000000000000000000000000000000000000000000000000000111111111111
    53.     private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);
    54.  
    55.     // 同一毫秒内的最新序号，最大值可为 2^12 - 1 = 4095
    56.     private long sequence;
    57.  
    58.     // workId位需要左移的位数 12
    59.     private static final long WORK_ID_SHIFT = SEQUENCE_BITS;
    60.  
    61.     // dataCenterId位需要左移的位数 12+5
    62.     private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
    63.  
    64.     // 时间戳需要左移的位数 12+5+5
    65.     private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;
    66.  
    67.     /**
    68.      * 无参构造
    69.      */
    70.     public SnowFlakeUtil() {
    71.         this(1, 1);
    72.     }
    73.  
    74.     /**
    75.      * 有参构造
    76.      * @param dataCenterId
    77.      * @param workerId
    78.      */
    79.     public SnowFlakeUtil(long dataCenterId, long workerId) {
    80.         // 检查dataCenterId的合法值
    81.         if (dataCenterId < 0 || dataCenterId > MAX_DATA_CENTER_ID) {
    82.             throw new IllegalArgumentException(
    83.                     String.format("dataCenterId 值必须大于 0 并且小于 %d", MAX_DATA_CENTER_ID));
    84.         }
    85.         // 检查workId的合法值
    86.         if (workerId < 0 || workerId > MAX_WORKER_ID) {
    87.             throw new IllegalArgumentException(String.format("workId 值必须大于 0 并且小于 %d", MAX_WORKER_ID));
    88.         }
    89.         this.workerId = workerId;
    90.         this.dataCenterId = dataCenterId;
    91.     }
    92.  
    93.     /**
    94.      * 获取唯一ID
    95.      * @return
    96.      */
    97.     public static Long getSnowFlakeId() {
    98.         return snowFlakeUtil.nextId();
    99.     }
    100.  
    101.     /**
    102.      * 通过雪花算法生成下一个id，注意这里使用synchronized同步
    103.      * @return 唯一id
    104.      */
    105.     public synchronized long nextId() {
    106.         long currentTimeMillis = System.currentTimeMillis();
    107.         System.out.println(currentTimeMillis);
    108.         // 当前时间小于上一次生成id使用的时间，可能出现服务器时钟回拨问题
    109.         if (currentTimeMillis < lastTimeMillis) {
    110.             throw new RuntimeException(
    111.                     String.format("可能出现服务器时钟回拨问题，请检查服务器时间。当前服务器时间戳：%d，上一次使用时间戳：%d", currentTimeMillis,
    112.                             lastTimeMillis));
    113.         }
    114.         if (currentTimeMillis == lastTimeMillis) {
    115.             // 还是在同一毫秒内，则将序列号递增1，序列号最大值为4095
    116.             // 序列号的最大值是4095，使用掩码（最低12位为1，高位都为0）进行位与运行后如果值为0，则自增后的序列号超过了4095
    117.             // 那么就使用新的时间戳
    118.             sequence = (sequence + 1) & SEQUENCE_MASK;
    119.             if (sequence == 0) {
    120.                 currentTimeMillis = getNextMillis(lastTimeMillis);
    121.             }
    122.         } else { // 不在同一毫秒内，则序列号重新从0开始，序列号最大值为4095
    123.             sequence = 0;
    124.         }
    125.         // 记录最后一次使用的毫秒时间戳
    126.         lastTimeMillis = currentTimeMillis;
    127.         // 核心算法，将不同部分的数值移动到指定的位置，然后进行或运行
    128.         // <<：左移运算符, 1 << 2 即将二进制的 1 扩大 2^2 倍
    129.         // |：位或运算符, 是把某两个数中, 只要其中一个的某一位为1, 则结果的该位就为1
    130.         // 优先级：<< > |
    131.         return
    132.                 // 时间戳部分
    133.                 ((currentTimeMillis - INIT_EPOCH) << TIMESTAMP_SHIFT)
    134.                 // 数据中心部分
    135.                 | (dataCenterId << DATA_CENTER_ID_SHIFT)
    136.                 // 机器表示部分
    137.                 | (workerId << WORK_ID_SHIFT)
    138.                 // 序列号部分
    139.                 | sequence;
    140.     }
    141.  
    142.     /**
    143.      * 获取指定时间戳的接下来的时间戳，也可以说是下一毫秒
    144.      * @param lastTimeMillis 指定毫秒时间戳
    145.      * @return 时间戳
    146.      */
    147.     private long getNextMillis(long lastTimeMillis) {
    148.         long currentTimeMillis = System.currentTimeMillis();
    149.         while (currentTimeMillis <= lastTimeMillis) {
    150.             currentTimeMillis = System.currentTimeMillis();
    151.         }
    152.         return currentTimeMillis;
    153.     }
    154.  
    155.     /**
    156.      * 获取随机字符串,length=13
    157.      * @return
    158.      */
    159.     public static String getRandomStr() {
    160.         return Long.toString(getSnowFlakeId(), Character.MAX_RADIX);
    161.     }
    162.  
    163.     /**
    164.      * 从ID中获取时间
    165.      * @param id 由此类生成的ID
    166.      * @return
    167.      */
    168.     public static Date getTimeBySnowFlakeId(long id) {
    169.         return new Date(((TIME_BIT & id) >> 22) + INIT_EPOCH);
    170.     }
    171.  
    172.     public static void main(String[] args) {
    173.         SnowFlakeUtil snowFlakeUtil = new SnowFlakeUtil();
    174.         long id = snowFlakeUtil.nextId();
    175.         System.out.println(id);
    176.         Date date = SnowFlakeUtil.getTimeBySnowFlakeId(id);
    177.         System.out.println(date);
    178.         long time = date.getTime();
    179.         System.out.println(time);
    180.         System.out.println(getRandomStr());
    181.  
    182.     }
    183.  
    184. }


    算法优缺点
    雪花算法有以下几个优点：

    高并发分布式环境下生成不重复 id，每秒可生成百万个不重复 id。
    基于时间戳，以及同一时间戳下序列号自增，基本保证 id 有序递增。
    不依赖第三方库或者中间件。
    算法简单，在内存中进行，效率高。
    雪花算法有如下缺点：

    依赖服务器时间，服务器时钟回拨时可能会生成重复 id。算法中可通过记录最后一个生成 id 时的时间戳来解决，每次生成 id 之前比较当前服务器时钟是否被回拨，避免生成重复 id。
    注意事项
    其实雪花算法每一部分占用的比特位数量并不是固定死的。例如你的业务可能达不到 69 年之久，那么可用减少时间戳占用的位数，雪花算法服务需要部署的节点超过1024 台，那么可将减少的位数补充给机器码用。

    注意，雪花算法中 41 位比特位不是直接用来存储当前服务器毫秒时间戳的，而是需要当前服务器时间戳减去某一个初始时间戳值，一般可以使用服务上线时间作为初始时间戳值。

    对于机器码，可根据自身情况做调整，例如机房号，服务器号，业务号，机器 IP 等都是可使用的。对于部署的不同雪花算法服务中，最后计算出来的机器码能区分开来即可。
     

  • 相关阅读:
    Web前端系列技术之Web APIs基础（从基础开始）①
    Java运行时jar时终端输出的中文日志是乱码
    机器学习可视化技术（Towards Data Science）
    Asoc codec bringup总结
    SCHNOKA施努卡：为什么要使用表面缺陷检测系统呢？
    如何裁剪音频文件？裁剪音频的方法有什么？
    DataFrame的操作-使用DSL
    【uniapp】华为APP真机运行（novas系列）
    Vant UI的Sidebar侧边导航组件单独设置滚动条
    【数据结构】详解堆的基本结构及其实现
  • 原文地址：https://blog.csdn.net/wufaqidong1/article/details/126863579