编号生成之snowflake雪花算法

简介
snowflake算法来源于Twitter，它能满足在分布式环境中生成唯一且呈递增趋势的纯数字编号的需求，并且不需要数据库等第三方的支持。雪花算法每秒大约能够生成26万个编号。

其缺点是依赖系统时钟，如果某台机器的时钟回拨或每台机器时钟不一致的情况下，会造成编号重复或乱序的情况。

实现原理
使用snowflake算法生成的编号是一个64bit大小的整数。

 * 1位符号位，0代表正数，1代表负数
 * 41位毫秒级时间戳 (当前时间 - 自定义开始时间)，大约可以使用69年
 * 10位数据机器（5位数据中心，5位机器ID）
 * 12位序列号，同一毫秒内可生成 2^12 - 1 = 4095 个序列号

Java代码

public class Snowflake {

    /**
     * 开始时间截 (2018-01-01)
     */
    private final long twepoch = 1514736000000L;

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

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

    /**
     * 支持的最大机器id，结果是31
     * maxWorkerId = 2^5 - 1
     */
    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
     * sequenceMask = 2^12 - 1
     */
    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;
    
	public void setWorkerId(long workerId) {
		if (workerId > maxWorkerId) {
			throw new RuntimeException("workerId 不能大于31.");
		}
		this.workerId = workerId;
	}

	public void setDatacenterId(long datacenterId) {
		if (datacenterId > maxDatacenterId) {
			throw new RuntimeException("datacenterId 不能大于31.");
		}
		this.datacenterId = datacenterId;
	}
	
	/**
	 * 生成编号
	 */
    public synchronized String nextValue() {
        long timestamp = timeGen();

        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("当前时间小于上次生成序列号的时间");
        }

        //如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            //毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            //时间戳改变，毫秒内序列重置
            sequence = 0L;
        }

        //上次生成ID的时间截
        lastTimestamp = timestamp;

        //移位并通过或运算拼到一起组成64位的ID
        long value = ((timestamp - twepoch) << timestampLeftShift)
            | (datacenterId << datacenterIdShift)
            | (workerId << workerIdShift)
            | sequence;

        return String.valueOf(value);
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     *
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    private long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * 当前时间(毫秒)
     */
    private long timeGen() {
        return System.currentTimeMillis();
    }

}

位运算

	a = 60;		//二进制    0011 1100
	b = 13;		//二进制    0000 1101

负数的二进制
在计算机中，负数的二进制是用补码来表示的。
补码 = 反码 + 1

int a = 5;
//a的原码：00000000 00000000 00000000 00000101
//a的反码：11111111 11111111 11111111 11111010
//a的补码：11111111 11111111 11111111 11111011 即-5的二进制表示

代码理解

	//sequenceBits = 12
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    // -1的二进制： 11111111 11111111 11111111 11111111
    // 左移12位得： 11111111 11111111 11110000 00000000
    //   异或运算： 00000000 00000000 00001111 11111111 转换成10进制为4095

	//sequenceMask = 4095
	sequence = (sequence + 1) & sequenceMask;
	//4095的二进制： 00000000 00000000 00001111 11111111
	//与运算：相应位都是1的情况下，才为1，否则为0
	//所以不论(sequence + 1)是多少，和sequenceMask进行与运算得到的结果都在0~4095之间

//timestampLeftShift = 22;datacenterIdShift = 17;workerIdShift = 12
//（timestamp - twepoch）:时间戳（41bit）；datacenterId：数据中心ID（5bit）
//workerId:机器ID（5bit）；sequence:序列号（12bit）
long value = ((timestamp - twepoch) << timestampLeftShift)
            | (datacenterId << datacenterIdShift)
            | (workerId << workerIdShift)
            | sequence;
//结合上图来看，此段代码就是将四个部分左移至应在位，使其不产生重叠，然后进行或运算得到一个64位的编号