分布式ID生成器

目标：全局唯一，较短，有序（最好连续且有意义），多点
有序的意义：有利于数据库索引（B+树）的效率

缺陷方案

1、数据库
方法：利用数据库自增ID
缺点：不全局唯一，有分表的系统中会出现相同ID，再扩容时难以处理

2、UUID
缺点：太长、无序

3、Redis
方法：在Redis上设置一个ID字段，客户端先调用incr（自增命令），再读取
缺点：加大了编码、配置、部署的工作量和复杂度，是对同一个字段的多步操作，可能造成一致性问题

4、Zookeeper
方法：在Zookeeper上设置一个ID节点，客户端先更新节点，再读取节点版本
缺点：加大了编码、配置、部署的工作量和复杂度，是对同一个节点的多步操作，可能造成一致性问题

5、MongoDB
方法：向MongoDB插入一条文档，再读取这条文档的ObjectId
缺点：必须有MongoDB集群，必须有插入数据的动作

6、Mycat
方法：select 1737091104517525504
缺点：加大了编码、配置、部署的工作量和复杂度，没有自带的集群（高可用）机制

Twitter Snowflake 方案

历史：Twitter于2004年开源Scala版的Snowflake
开源地址：https://github.com/twitter-archive/snowflake

原理：每个节点自己生成与时间和机器有关的ID
不足：1、节点间的时间必须基本同步，且不能回拨；2、ID有序不连续；3、每个节点需要知道自己的节点编号

Snowflake 应用组成
1、ID生成器

/**
 * Twitter_Snowflake
 * SnowFlake的结构如下(每部分用-分开):
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
 * 41位时间戳(毫秒级)，存储时间戳的差值（当前时间戳 - 指定的startTime)。41位的时间戳，可以使用69年
 * 10位的数据机器位，可以部署在1024个节点，包括5位dataCenterId和5位workerId
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间戳)产生4096个ID序号
 * 加起来刚好64位，为一个Long型。
 */
public class IdWorker {
    /** 开始时间戳 (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;


    /**
     * 构造函数
     * @param workerId 工作ID (0~31)
     * @param dataCenterId 数据中心ID (0~31)
     */
    public IdWorker( long dataCenterId, long workerId) {
        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;
    }

    /**
     * 获得下一个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();
    }
}

2、使用

IdWorker idWorker = new IdWorker(0, 0); // 传入本机的 数据中心ID 和 节点ID，这两个值可以通过 jar 启动参数传入
long id = idWorker.nextId();
System.out.println(id);

Snowflake 结合 zookeeper

利用 zookeeper 的有序节点可以得到本机的编号，从而确定dataCenterId、workerId

阿里云

阿里云DRDS：ID采用DRDS Sequence，全局唯一，有序递增的数字序列。将来要导入DRDS的数据，ID最好就是自增数字序列

相关组件

百度 UidGenerator
美团 Leaf-snowflake

SpringBoot 整合 Leaf-snowflake

1、在git bash中，下载

git clone [email protected]:Meituan-Dianping/Leaf.git
cd Leaf
git checkout feature/spring-boot-starter

2、在cmd中，安装到maven本地仓库

cd Leaf
mvn clean install -Dmaven.test.skip=true

3、pom.xml

    com.fasterxml.jackson.core  
    jackson-core
    2.9.5


    com.fasterxml.jackson.core
    jackson-databind
    2.9.5


    org.apache.curator
    curator-recipes
    2.13.0


    leaf-boot-starter
    com.sankuai.inf.leaf
    1.0.1-RELEASE

4、在resource目录下新建 leaf.properties

leaf.segment.enable=false
leaf.snowflake.enable=true
leaf.snowflake.address=zookeeper地址

5、主程序文件加注释 @EnableLeafServer
6、使用

@Autowired
private SnowflakeService snowflakeService;

long id = snowflakeService.getId("key").getId();