雪花算法及分布式主键生成策略详解

目前雪花算法常应用于分布式环境下作为分布式主键的首选，本文详细介绍下雪花算法及相关分布式主键的生成策略。

如下内容已本文PPT讲解内容为基础。

本次内容共包括4部分：分布式主键生成策略，雪花算法详解，项目中如何使用，雪花算法升级。

1.分布式主键生成策略 

分布式环境下主键具有哪些特点：

1、全局唯一性：不能出现重复的主键ID号
2、保证逻辑递增：Mysql 中InnoDB引擎为聚集索引，有序的主键保证写入性能。
3、信息安全：防止用户恶意收集数据。订单或用户是连续话，可以很容易知道对应核心数据。
 

那么，分布式主键的解决方案有哪些呢？

目前常用的共4种：

UUID,DB生成，Redis生成，雪花算法。 

4种主键生成策略也有各自的优缺点：

UUID：

优点
1.性能很高，本地生成，没有网络消耗

缺点
1.长度太长，不易存储(16或者36长度的字符串)。
2.造成MAC地址泄露(如下)。
3.DB主键的场景下，主键采用UUID非常不合适
4.并发量超过1000，会生成重复ID

DB

优点
1.实现简单
2.ID递增
缺点
1.强依赖DB

Redis

优点
1.速度快，性能优于DB
2.ID递增
缺点：
1.递增

雪花算法

优点
1.天然为分布式ID的解决方案
Id逻辑递增，
适配DB水平分表后主键策略
2.不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的
缺点
1.如果唯一标识有重复，会造成ID冲突。
2.如果系统时间回拨, 会造成ID冲突。

相比于其他三种，雪花算法其实是专门为分布式环境下设计的。接下来详细说下雪花算法的机制和原理

雪花算法详解

这里需要特别注意，雪花算法可以实现分布式环境下唯一主键的关键就在中间10bit的内容。

10bit由2部分内容组成，及datacenter和workerId，

在分布式环境下若datacenter相同的情况下workerId必须不同，否则可能会造成主键冲突。

另外，雪花算法由于其自身的设计，还是有一定局限性的，这也就是为什么美团和百度基于雪花算法分别升级了自己的内容的原因。

在看雪花算法的源码之前，需要思考3个问题：

/**
 * Twitter_Snowflake

 * SnowFlake的结构如下(每部分用-分开):

 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 

 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0

 * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
 * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69

 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId

 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号

 * 加起来刚好64位，为一个Long型。

 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
 */
public class SnowflakeIdWorker {

    // ==============================Fields===========================================
    /** 开始时间截 (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;

    //==============================Constructors=====================================
    /**
     * 构造函数
     * @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;
    }

    // ==============================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();
    }

    //==============================Test=============================================
    /** 测试 */
    public static void main(String[] args) {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 1000; i++) {
            long id = idWorker.nextId();
            System.out.println(Long.toBinaryString(id));
            System.out.println(id);
        }
    }
}

 如上为雪花算法的JAVA版源码，针对上面提到的3个问题，若有不清楚，可随时联系沟通，文章后附联系方式。

雪花算法的应用场景

目前随着微服务的流行，雪花算法被广泛应用于各种组件插件中。

如mybatise-plus,shardingsphere等

若再项目中使用，可以通过第三方类库进行直接调用，如 hutool。

雪花算法升级 

针对雪花算法的局限性，目前最著名的是美团和百度在原雪花算法基础上进行的升级。

这部分内容这里就不展开讲解了，感兴趣的自己可以进行相关学习和了解。

以上为全部内容。

星光不问赶路人，时光不负有心人。