服务器有校时情况下的雪花算法改进

最近由于项目需要，要用到雪花算法生成ID，所以到网上找了个java的实现版本

原版代码如下：

 

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Twitter_Snowflake<br>
 * SnowFlake的结构如下(每部分用-分开):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
 * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
 * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
 * 加起来刚好64位，为一个Long型。<br>
 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
 */
public class SnowflakeIdWorker {

    private static final Logger logger = LoggerFactory.getLogger(SnowflakeIdWorker.class);

    private static final SnowflakeIdWorker INSTANCE;

    static {
        long workId = 0;
        long dataCenterId = 0;
        try {
            String localHostIpString = HostIpUtils.getLocalHostIpString();
            logger.info("获取的本机IP为： "+ localHostIpString);
            String[] array = localHostIpString.split("\\.");
            long sum = 0;
            for (String s : array) {
                sum += Long.parseLong(s);
            }
            long max = 1 << 5;
            dataCenterId = sum / max;
            workId = sum % max;
            logger.info("初始化生成的机房ID:" + dataCenterId + "\t机器ID：" +workId);

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("雪花算法id生成器初始化失败");
        }
        INSTANCE = new SnowflakeIdWorker(workId, dataCenterId);
    }

    // ==============================Fields===========================================
    /** 开始时间截 (2015-01-01) */
    //TODO 开始时间戳的选择影响生成的id长度，选取时间越靠前，则生成id越长，最长为19位，最短为9位
    private final long twepoch = 1420041600000L;

    /** 机器id所占的位数 */
    private static final long workerIdBits = 5L;

    /** 数据标识id所占的位数 */
    private static final long datacenterIdBits = 5L;

    /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    public static final long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /** 支持的最大数据标识id，结果是31 */
    public static 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)
     */
    private 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();
    }

    public static long getNextLongId() {
        return INSTANCE.nextId();
    }

    public static String getNextId() {
        return INSTANCE.nextId() + "";
    }

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

然后要根据项目需要做些改进，首先就是datacenterId和workerId的初始化问题，在网上找了些文章看，最后总结以下三个思路

1、服务器单机算法，通过获取服务器自身的某些标识来确定workId,但由于生成的workId有两个基本的要求，其一是唯一性，不能重复，其二是取值范围0-1023，也就是一共只能有1024个不同值，所以获取的服务器标识的值必须小于1024种可能，大于的话，由标识映射到workId就不能保证唯一性了，能符合这两个要求的标识暂时没有想到，因为像硬件序列号，为保证区分不同电脑，基本都有上亿以上的取值可能，不能满足要求，暂时只能想到IP在前三个数固定的同一网段上，能满足这样的要求，不过实际的可操作性还要看
2、部署时注入环境变量，这样部署会比较麻烦，
3、利用第三方服务来实现，例如网上可以找到的用etcd或zk来发号

由于不想部署时麻烦，实际部署时的网段是前两位固定，所以前两个思路都被否了，只能用第三个方案，不过项目用的spring cloud构建的微服务，没有用到zk，倒是用到了redis，所以考虑借助redis来实现发号

利用redis发号的逻辑大概如下：

雪花算法ID生成器类加载时，先获取redis的分布式锁，没获取到，就等待直到获取到，然后按指定的workId(workerId和datacenterId共十位确定的0-1023范围内的值)，分配保存的前缀查询所有在redis分配到的workId，然后找到0-1023范围内没被分配的最小的workId号，把这个号拼上前缀保存到redis，有效期一小时，然后设定一个定时任务，每半小时执行一次，把分配到的workId号加固存到redis，避免这个号过期后，再被分配。

这样workId分配的问题就解决了，然后又遇了新的问题，就是应用部署后需要校时，也就是有一定概率发生时间回调，原算法中发生时间回调后，调用会直接抛异常，这个逻辑显示不能接受，所以需要改进，之前在网上查看雪花算法时，也看到有应对时间回调的方案，不过我突然自己想到了两个思路，所以没有再去网上查其他的方案了，下面是我想到的两个思路：

方案一是发现时钟回拨后，算出来回拨多少，保存为时间偏移量，然后后面每次获取时间戳都加上偏移量，每回拨一次更新一次偏移量
方案二是，只在第一次生成id或启动时获取时间戳并保存下来，每生成一个id，就计下数，每个毫秒数能生成的id数是固定的，到生成满了，再把时间戳加一，这样就不依赖于系统时间了，每个毫秒数的使用率也最高

经过一翻考虑，最终采用了方案一，并写了个demo，demo代码git库地址：https://gitee.com/regedit0726/snowflake

demo中写了单元测试，分别验证了单线程和多线程，以及多线程并发生时间回调那个情况下的生成ID的唯一性，并各自测算了每秒生成ID数量的效率，在我本地跑测试，单线程大概每秒生成五六十万个ID，多线程大概三四十万个ID。