集群、分布式 高并发的情况下如何生成全局唯一ID

集群高并发的情况下如何生成全局唯一ID

1，ID生成规则的硬性要求：

1. 全局唯一
2. 趋势递增
3. 单调递增
4. 信息安全
5. 含时间戳

2，ID生成系统的可用性要求：

1. 高可用
2. 低延迟
3. 高QPS：10万个的请求同时过来。

3，生成全局唯一ID的主要方案：

1. 中间件方式：可以通过数据库或 redis 缓存作为媒介，通过数据库生成自增ID来作为唯一ID。数据库的自增ID机制的原理是：数据库自增ID的mysql 的 repalce into 实现的（没有新增有则替换，字段创建唯一索引），缺点：系统水平扩展困难，依赖中间件(假如中间件挂了呢)。

2. UUID方式：UUID 是JDK (java.util.UUID) 提供的，使用UUID实现全局唯一的效率低。因为UUID的长度是36位且无须。常用的 mysql 数据库的话，既然分布式id是主键，然后主键时包含索引的，然后mysql的索引是通过b+树来实现的，每一次新的UUID数据的插入，为了查询的优化，都会对索引底层的b+树进行修改，因为UUID数据都是无序的，所以每一次UUID数据的插入都会对主键的b+树进行很大的修改，这一点很不好，插入完全无序，不但会导致一些中间节点产生分裂，也会白白创造出很多不饱和的节点，这样大大降低了数据库插入的性能。

3. redis 全局生成 id 策略，因为redis 的单线程保证了原子性，可以使用原子性操作INCR和INCRBY来实现，注意在Redis集群情况下，同MySQL一样需要设置不同的增长步长，同时key一定要设置有效期，可以使用Redis集群来获取更高的QPS。

4. 通过 snowflake(雪花)算法：
   4.1.通过 SnowFlake 算法得到的是一个64bit 大小的整数。
   
   1) 1位，不用。二进制中最高位是为1都是复数，但是要生成的唯一ID都是整数，所以这个1位固定为0。
   2) 41位， 用来记录时间戳(毫秒)。
   3) 10位，用来记录工作机器的ID。
   4) 12位， 序列号，就是某个机房某台机器上这一毫秒内同时生成的 id 序号 。
   优点：
   1.所有生成的ID都是按照时间趋势增加。
   2.整个分布式系统都不会产生重复ID(因为有datacenterId和workerId来做区分)。

5. Java 实现SnowFlake算法.

	package com.ht.snow

/**
 * 分布式雪花ID算法
 * 
 * @author zhi
 * @since 2019年5月14日16:51:06
 *
 */
public class SnowFlake {
    /**
     * 起始的时间戳
     */
    private final static long twepoch = 1557825652094L;

    /**
     * 每一部分占用的位数
     */
    private final static long workerIdBits = 5L;
    private final static long datacenterIdBits = 5L;
    private final static long sequenceBits = 12L;

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

    /**
     * 每一部分向左的位移
     */
    private final static long workerIdShift = sequenceBits;
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    private final static long timestampShift = sequenceBits + workerIdBits + datacenterIdBits;

    private long datacenterId; // 数据中心ID
    private long workerId; // 机器ID
    private long sequence = 0L; // 序列号
    private long lastTimestamp = -1L; // 上一次时间戳

    public SnowFlake(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;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format(
                    "Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & maxSequence;
            if (sequence == 0L) {
                timestamp = tilNextMillis();
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = timestamp;

        return (timestamp - twepoch) << timestampShift // 时间戳部分
                | datacenterId << datacenterIdShift // 数据中心部分
                | workerId << workerIdShift // 机器标识部分
                | sequence; // 序列号部分
    }

    private long tilNextMillis() {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    private long timeGen() {
        return System.currentTimeMillis();
    }
}