雪花算法

雪花算法分析

• 首先，雪花算法有64位二进制数；从左往右数，
• 第1位是符号位(默认是零，不用做处理)，
• 第2位~第42位(共41位),表示时间戳,因为41位二进制所能表达最大的数(十进制)是：2199023255551(单位是毫秒) 换算成年就是69.73057
• 第43位~第52位(共10位),这十位分成平均两段(也就是各五位)(那么前五位可以表示你在哪个机房,后五位可以表示你在某个机房的第几台机器;所以这十位就是自定义的，分布式微服务就需要
• 最后的12位,用于多个请求在同一毫秒内同时到达,需要给它们分配不同的id；范围是0~4095(4096种)，所以在同一毫秒内，最多可以给4096给请求分配id，如果超过了那就强行让第4097个请求开始等待，等这一毫秒过了，才给分配id(后面有讲如何 强行等待)

public class Snowflake {

    /**
     * 每一部分所占位数
     */
    private final long unusedBits = 1L;  //符号位，默认是0 代表正数
    private final long timestampBits = 41L; //时间戳，毫秒为单位  从1970.1开始至2039.X
    private final long datacenterIdBits = 5L; // 机器号 ----可以改变
    private final long workerIdBits = 5L; //机房号  ----可以改变
    private final long sequenceBits = 12L;//序列号，同一机器同一毫秒内产生不同的序列号，12 bit 可以支持 4096 个序列号

    /**
     * 向左的位移的位数
     */
    private final long timestampShift = sequenceBits + datacenterIdBits + workerIdBits;
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    private final long workerIdShift = sequenceBits;

    /**
     * 起始时间戳，初始化后不可修改
     */
    private final long epoch = 1451606400000L; 

    /**
     * 数据中心编码，初始化后不可修改
     * 最大值: 2^5-1 取值范围: [0,31]
     */
    private final long datacenterId;

    /**
     * 机器或进程编码，初始化后不可修改
     * 最大值: 2^5-1 取值范围: [0,31]
     */
    private final long workerId;

    /**
     * 序列号
     * 最大值: 2^12-1 取值范围: [0,4095]
     */
    private long sequence = 0L;

    /** 上次执行生成 ID 方法的时间戳 */
    private long lastTimestamp = -1L;

    /*
     * 每一部分最大值
     */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 2^5-1
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits); // 2^5-1
    private final long maxSequence = -1L ^ (-1L << sequenceBits); // 2^12-1



    //构造函数，自定义机房和机器号
    public Snowflake(long datacenterId, long workerId) {
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(
                    String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(
                    String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }

        this.datacenterId = datacenterId;
        this.workerId = workerId;
    }

    /**
     * 生成序列号
     */
    public synchronized long nextId() {

        //获取当前时间
        long currTimestamp = timestampGen();

        //如果当前时间小于上次分配id的时间，直接报错；因为越往后时间不可能减少的
        if (currTimestamp < lastTimestamp) {
            throw new IllegalStateException(
                    String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",
                            lastTimestamp - currTimestamp));
        }

        //这如果当前时间等于上次分配id的时间 ，同一毫秒有多个请求，
        if (currTimestamp == lastTimestamp) {

            //为什么要&呢？因为如果不加就会超过(2的12次方)+1,那样12位就放不下了
            sequence = (sequence + 1) & maxSequence;

            //如果同一毫秒内超过了(2的12次方)+1个请求时，让第(2的12次方)+1+1 个请求等一毫秒
            if (sequence == 0) {
                currTimestamp = waitNextMillis(currTimestamp);
            }

        } else {
            //记得清零
            sequence = 0L;
        }

        // 更新上次分配id的时间
        lastTimestamp = currTimestamp;

        //
        return ((currTimestamp - epoch) << timestampShift) | //
                (datacenterId << datacenterIdShift) | //
                (workerId << workerIdShift) | // new line for nice looking
                sequence;
    }

    
    /**
     * 循环阻塞直到下一毫秒,就是用while来浪费时间
     */
    protected long waitNextMillis(long currTimestamp) {
        currTimestamp = timestampGen();
        while (currTimestamp <= lastTimestamp) {
            currTimestamp = timestampGen();
        }
        return currTimestamp;
    }

    /**
     * 获取当前时间戳
     */
    public long timestampGen() {
        return System.currentTimeMillis();
    }
}