生成分布式ID的n种方法，你知道多少种

前言

在分布式系统中，经常需要对大量的数据进行唯一标识。普通的数据库自增主键已经不能满足需求，

需要一个能够生成全局唯一ID的系统，这个系统需要满足以下需求：

全局唯一：不能出现重复ID。

高可用：ID生成系统是基础系统，被许多关键系统调用，一旦宕机，会造成严重影响。所以需要保证高可用。

在分布式系统中生成唯一ID的方案有很多，常见的方式有以下几种

1、采用数据库ID生成策略

数据库有一些自己的ID生成策略，如Mysql的自增ID，Oracle的SEQUENCE序列。单独使用一个数据库实例，在这个实例中新建一个单独的ID表。通过插入一条记录来让数据库生成ID。

优点
实现简单，成本小。

缺点
依赖数据库，存在单点问题，如果数据库宕机，则业务不可用。

数据库生成ID性能有限，单点数据库压力大，无法扛高并发场景。

适用场景
小规模的，数据访问量小的业务场景。

实现：

//创建一个ID表

CREATE TABLE Tickets64 (
    id bigint(20) unsigned NOT NULL auto_increment,
    stub char(1) NOT NULL default '',
    PRIMARY KEY (id),
    UNIQUE KEY stub (stub)
)ENGINE=MyISAM;

#每次业务使用下列SQL插入数据库，生成ID，获取最新生成的ID

//插入数据，value为数据值，可以是任意一个字符
REPLACE INTO Tickets64 (stub) VALUES (value);

//获取最后插入的ID值
SELECT LAST_INSERT_ID();

SELECT LAST_INSERT_ID()：得到刚 insert 进去记录的主键值，只适用与自增主键；

集群数据库生成ID

解决数据库单点问题，我们可以用一个数据库集群来生成ID。

比如使用Mysql集群模式，用多个Mysql实例来生成ID，但这样有个问题就是如果Mysql的实例都是从1开始，那么就会有重复的id出现。

解决方法：

设置起始值和自增步长

例：

MySQL_1 配置：

set @@auto_increment_offset = 1;     -- 起始值
set @@auto_increment_increment = 2;  -- 步长

MySQL_2 配置：

set @@auto_increment_offset = 2;     -- 起始值
set @@auto_increment_increment = 2;  -- 步长

这样第一个实例生成的ID就是1，3，5。第二个实例生成的ID就是2，4，6

缺点

扩容比较困难，而且单个数据库本身的压力还是大，可能还是无法满足高并发。

2、使用UUID生成ID

UUID有着全球唯一的特性，其实UUID是满足分布式ID的要求的，也是最简单的方法。但是，并不被推荐。因为它有以下的缺点

优点
实现简单，易用。

本地生成，性能较好。

具备全球唯一的特性。

缺点
每次生成的ID都是无序的，而且不是全数字，且无法保证趋势递增。

UUID生成的是字符串，字符串存储性能差，查询效率慢。

UUID长度过长，不适用于存储，耗费数据库性能。

ID无一定业务含义，可读性差。

实现

//java中的使用：
String uuid = UUID.randomUUID().toString().replaceAll("-","");

Redis ID生成器

当使用数据库来生成ID性能不够要求的时候，我们可以尝试使用Redis来生成ID。这主要依赖于Redis是单线程的，所以也可以用生成全局唯一的ID。可以用Redis的原子操作 INCR和INCRBY来实现递增。可以使用Redis集群来获取更高的吞吐量。

set seq_id 1     // 初始化自增ID为1

incr seq_id      // 增加1，并返回

当然，你也可以根据业务来选择ID的生成策略。比如：时间戳+唯一标识+随机数，只要保证唯一即可。

优点：

不依赖于数据库，灵活方便，且性能优于数据库。

对于已经有Redis组件的系统，这是个不错的选择。

雪花算法（snowflake）

snowflake是twitter开源的分布式ID生成算法，是一种算法。

SnowFlake算法生成id的结果是一个64bit大小的整数，它的结构如下图：

1、第一个bit位是标识部分，在java中由于long的最高位是符号位，正数是0，负数是1，生成的id一般都是用整数，所以固定为0。

2、41bit-时间戳，用来记录时间戳，毫秒级。41位可以表示2^{{41}-1个数字，也就是说41位可以表示2}{41}-1个毫秒的值，转化成单位年则是69年。一般是时间戳的差值（当前时间-固定的开始时间），而不是当前时间戳。

3、工作机器id占10bit，用来记录工作机器id。比如，可以使用前5位作为数据中心机房标识，后5位作为单机房机器标识，可以部署1024个节点。

4、12bit-序列号，序列号，用来记录同毫秒内产生的不同id。12位（bit）可以表示的最大正整数是2^{12}-1 = 4095，即支持同一毫秒内同一个节点可以生成4096个ID

根据这个算法，我们可以用代码实现一个ID生成工具。

下面是github上的一个雪花算法实现，大家可以参考参考

public class SnowFlake {

    /**
     * 起始的时间戳
     */
    private final static long START_STMP = 1480166465631L;

    /**
     * 每一部分占用的位数
     */
    private final static long SEQUENCE_BIT = 12; //序列号占用的位数
    private final static long MACHINE_BIT = 5;   //机器标识占用的位数
    private final static long DATACENTER_BIT = 5;//数据中心占用的位数

    /**
     * 每一部分的最大值
     */
    private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
    private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
    private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);

    /**
     * 每一部分向左的位移
     */
    private final static long MACHINE_LEFT = SEQUENCE_BIT;
    private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
    private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;

    private long datacenterId;  //数据中心
    private long machineId;     //机器标识
    private long sequence = 0L; //序列号
    private long lastStmp = -1L;//上一次时间戳

    public SnowFlake(long datacenterId, long machineId) {
        if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
            throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");
        }
        if (machineId > MAX_MACHINE_NUM || machineId < 0) {
            throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
        }
        this.datacenterId = datacenterId;
        this.machineId = machineId;
    }

    /**
     * 产生下一个ID
     *
     * @return
     */
    public synchronized long nextId() {
        long currStmp = getNewstmp();
        if (currStmp < lastStmp) {
            throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
        }

        if (currStmp == lastStmp) {
            //相同毫秒内，序列号自增
            sequence = (sequence + 1) & MAX_SEQUENCE;
            //同一毫秒的序列数已经达到最大
            if (sequence == 0L) {
                currStmp = getNextMill();
            }
        } else {
            //不同毫秒内，序列号置为0
            sequence = 0L;
        }

        lastStmp = currStmp;

        return (currStmp - START_STMP) << TIMESTMP_LEFT //时间戳部分
                | datacenterId << DATACENTER_LEFT       //数据中心部分
                | machineId << MACHINE_LEFT             //机器标识部分
                | sequence;                             //序列号部分
    }

    private long getNextMill() {
        long mill = getNewstmp();
        while (mill <= lastStmp) {
            mill = getNewstmp();
        }
        return mill;
    }

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

    public static void main(String[] args) {
        SnowFlake snowFlake = new SnowFlake(2, 3);

        for (int i = 0; i < (1 << 12); i++) {
            System.out.println(snowFlake.nextId());
        }

    }
}

使用上面的工具类生成雪花id，只需要先传入两个Long类型的数值（一个machineId机器标识，一个datacenterId数据中心标识）
如：

public static String getSnowFlakeNo() {
    return String.valueOf(new SnowFlake(2L, 6L).nextId());
}

各大公司实现的分布式ID框架

美团的Leaf ：https://github.com/Meituan-Dianping/Leaf

百度的uid-generator：https://github.com/baidu/uid-generator