Ref: https://pdai.tech/md/algorithm/alg-domain-id-snowflake.html

    Snowflake，雪花算法是由 Twitter 开源的分布式 ID 生成算法，以划分命名空间的方式将 64-bit 位分割成多个部分，每个部分代表不同的含义。而 Java 中 64bit 的整数是 Long 类型，所以在 Java 中 SnowFlake 算法生成的 ID 就是 long 来存储的。

    • 第 1 位占用 1bit，其值始终是 0，可看做是符号位不使用。
    • 第 2 位开始的 41 位是时间戳，41-bit 位可表示 2^41 个数，每个数代表毫秒，那么雪花算法可用的时间年限是 (1L<<41)/(1000L360024*365)=69 年的时间。
    • 中间的 10-bit 位可表示机器数，即 2^10 = 1024 台机器，但是一般情况下我们不会部署这么台机器。如果我们对 IDC（互联网数据中心）有需求，还可以将 10-bit 分 5-bit 给 IDC，分 5-bit 给工作机器。这样就可以表示 32 个 IDC，每个 IDC 下可以有 32 台机器，具体的划分可以根据自身需求定义。
    • 最后 12-bit 位是自增序列，可表示 2^12 = 4096 个数。

    这样的划分之后相当于在一毫秒一个数据中心的一台机器上可产生 4096 个有序的不重复的 ID。但是我们 IDC 和机器数肯定不止一个，所以毫秒内能生成的有序 ID 数是翻倍的。
    image.png
    Snowflake 的 Twitter 官方原版是用 Scala 写的，对 Scala 语言有研究的同学可以去阅读下，以下是 Java 版本的写法。

    1. package com.jajian.demo.distribute;
    3. /**
    4.  * Twitter_Snowflake<br>
    5.  * SnowFlake的结构如下(每部分用-分开):<br>
    6.  * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
    7.  * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
    8.  * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
    9.  * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
    10.  * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
    11.  * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
    12.  * 加起来刚好64位，为一个Long型。<br>
    13.  * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
    14.  */
    15. public class SnowflakeDistributeId {
    18.     // ==============================Fields===========================================
    19.     /**
    20.      * 开始时间截 (2015-01-01)
    21.      */
    22.     private final long twepoch = 1420041600000L;
    24.     /**
    25.      * 机器id所占的位数
    26.      */
    27.     private final long workerIdBits = 5L;
    29.     /**
    30.      * 数据标识id所占的位数
    31.      */
    32.     private final long datacenterIdBits = 5L;
    34.     /**
    35.      * 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
    36.      */
    37.     private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    39.     /**
    40.      * 支持的最大数据标识id，结果是31
    41.      */
    42.     private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    44.     /**
    45.      * 序列在id中占的位数
    46.      */
    47.     private final long sequenceBits = 12L;
    49.     /**
    50.      * 机器ID向左移12位
    51.      */
    52.     private final long workerIdShift = sequenceBits;
    54.     /**
    55.      * 数据标识id向左移17位(12+5)
    56.      */
    57.     private final long datacenterIdShift = sequenceBits + workerIdBits;
    59.     /**
    60.      * 时间截向左移22位(5+5+12)
    61.      */
    62.     private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    64.     /**
    65.      * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
    66.      */
    67.     private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    69.     /**
    70.      * 工作机器ID(0~31)
    71.      */
    72.     private long workerId;
    74.     /**
    75.      * 数据中心ID(0~31)
    76.      */
    77.     private long datacenterId;
    79.     /**
    80.      * 毫秒内序列(0~4095)
    81.      */
    82.     private long sequence = 0L;
    84.     /**
    85.      * 上次生成ID的时间截
    86.      */
    87.     private long lastTimestamp = -1L;
    89.     //==============================Constructors=====================================
    91.     /**
    92.      * 构造函数
    93.      *
    94.      * @param workerId     工作ID (0~31)
    95.      * @param datacenterId 数据中心ID (0~31)
    96.      */
    97.     public SnowflakeDistributeId(long workerId, long datacenterId) {
    98.         if (workerId > maxWorkerId || workerId < 0) {
    99.             throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
    100.         }
    101.         if (datacenterId > maxDatacenterId || datacenterId < 0) {
    102.             throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
    103.         }
    104.         this.workerId = workerId;
    105.         this.datacenterId = datacenterId;
    106.     }
    108.     // ==============================Methods==========================================
    110.     /**
    111.      * 获得下一个ID (该方法是线程安全的)
    112.      *
    113.      * @return SnowflakeId
    114.      */
    115.     public synchronized long nextId() {
    116.         long timestamp = timeGen();
    118.         //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
    119.         if (timestamp < lastTimestamp) {
    120.             throw new RuntimeException(
    121.                     String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
    122.         }
    124.         //如果是同一时间生成的，则进行毫秒内序列
    125.         if (lastTimestamp == timestamp) {
    126.             sequence = (sequence + 1) & sequenceMask;
    127.             //毫秒内序列溢出
    128.             if (sequence == 0) {
    129.                 //阻塞到下一个毫秒,获得新的时间戳
    130.                 timestamp = tilNextMillis(lastTimestamp);
    131.             }
    132.         }
    133.         //时间戳改变，毫秒内序列重置
    134.         else {
    135.             sequence = 0L;
    136.         }
    138.         //上次生成ID的时间截
    139.         lastTimestamp = timestamp;
    141.         //移位并通过或运算拼到一起组成64位的ID
    142.         return ((timestamp - twepoch) << timestampLeftShift) //
    143.                 | (datacenterId << datacenterIdShift) //
    144.                 | (workerId << workerIdShift) //
    145.                 | sequence;
    146.     }
    148.     /**
    149.      * 阻塞到下一个毫秒，直到获得新的时间戳
    150.      *
    151.      * @param lastTimestamp 上次生成ID的时间截
    152.      * @return 当前时间戳
    153.      */
    154.     protected long tilNextMillis(long lastTimestamp) {
    155.         long timestamp = timeGen();
    156.         while (timestamp <= lastTimestamp) {
    157.             timestamp = timeGen();
    158.         }
    159.         return timestamp;
    160.     }
    162.     /**
    163.      * 返回以毫秒为单位的当前时间
    164.      *
    165.      * @return 当前时间(毫秒)
    166.      */
    167.     protected long timeGen() {
    168.         return System.currentTimeMillis();
    169.     }
    170. }

    雪花算法提供了一个很好的设计思想，雪花算法生成的 ID 是趋势递增，不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成 ID 的性能也是非常高的，而且可以根据自身业务特性分配 bit 位，非常灵活。

    但是雪花算法强依赖机器时钟，如果机器上时钟回拨，会导致发号重复或者服务会处于不可用状态。如果恰巧回退前生成过一些 ID，而时间回退后，生成的 ID 就有可能重复。官方对于此并没有给出解决方案，而是简单的抛错处理，这样会造成在时间被追回之前的这段时间服务不可用。

    很多其他类雪花算法也是在此思想上的设计然后改进规避它的缺陷，后面介绍的百度 UidGenerator 和 美团分布式ID生成系统 Leaf 中 snowflake 模式都是在 snowflake 的基础上演进出来的。