image-20210124162352373.png

一、前言

这周网上的各种瓜真的是吃到肚子里都是水啊。按照惯例周末聊点轻松的，这次我们讲几种全局唯一ID。

平常一些小项目，我们用数据库自增ID就够了，但如果做了分布式、多主数据库、分表分库等场景，那数据库自增可能就无法满足业务需求了。所以这里介绍几种唯一ID的设计，客官根据实际项目按需选择了。

二、唯一ID的几种方式

1. 数据库自增

当服务使用的数据库只有单库单表时，可以直接使用数据库的自增，如MySQL的auto_increment、CockroachDB的SERIAL PRIMARY KEY等。

优点：

• 简单，无需程序任何附加操作
• 保持定长的增量
• 在单表中能保持唯一性

缺点：

• 高并发下性能不佳，主键产生的性能上限是数据库服务器单机的上限
• 水平扩展困难，在分布式数据库环境下，无法保证唯一性

2. UUID

UUID 是 通用唯一识别码（Universally Unique Identifier）的缩写，一般在程序语言当中实现。

优点：

• 本地生成ID，不需要进行远程调用
• 本机生成，没有性能问题
• 因为是全球唯一的ID，水平扩展能力非常好

缺点：

• 每次生成的ID是无序的且没有带Timestamp，无法保证趋势递增
• ID有128 bits,占用的空间较大，需要存成字符串类型，索引效率极低

3. 雪花ID

雪花ID snowflake是twitter开源的分布式ID生成算法，其核心思想是：产生一个long型的ID，使用其中41bit作为毫秒数，10bit作为机器编号，12bit作为毫秒内序列号。这个算法单机每秒内理论上最多可以生成1000*(2^12)个，也就是大约400W的ID，完全能满足业务的需求。

image-20210124165731875.png

组成部分（64bit）

1.第一位 占用1bit，其值始终是0，没有实际作用。 2.时间戳 占用41bit，精确到毫秒，总共可以容纳约69年的时间。 3.工作机器id 占用10bit，其中高位5bit是数据中心ID，低位5bit是工作节点ID，做多可以容纳1024个节点。 4.序列号 占用12bit，每个节点每毫秒0开始不断累加，最多可以累加到4095，一共可以产生4096个ID。

SnowFlake算法在同一毫秒内最多可以生成多少个全局唯一ID呢：： 同一毫秒的ID数量 = 1024 X 4096 = 4194304

雪花算法的实现

雪花算法的实现主要依赖于数据中心ID和数据节点ID这两个参数，具体实现如下。

JAVA版本：

public class SnowflakeIdWorker {
    /**
     * 开始时间截 (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 SnowflakeIdWorker(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;
    }
    /**
     * 获得下一个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();
    }

    public static void main(String[] args) throws InterruptedException {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 10; i++) {
            long id = idWorker.nextId();
            Thread.sleep(1);
            System.out.println(id);
        }
    }
}

Python实现

# coding: utf-8
import time


class InvalidSystemClock(Exception):
    """
    时钟回拨异常
    """
    pass

# 64位ID的划分
WORKER_ID_BITS = 5
DATACENTER_ID_BITS = 5
SEQUENCE_BITS = 12

# 最大取值计算
MAX_WORKER_ID = -1 ^ (-1 << WORKER_ID_BITS)  # 2**5-1 0b11111
MAX_DATACENTER_ID = -1 ^ (-1 << DATACENTER_ID_BITS)

# 移位偏移计算
WOKER_ID_SHIFT = SEQUENCE_BITS
DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS
TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS

# 序号循环掩码
SEQUENCE_MASK = -1 ^ (-1 << SEQUENCE_BITS)

# 开始时间截 (2015-01-01)
TWEPOCH = 1420041600000


class IdWorker(object):
    """
    用于生成IDs
    """
    def __init__(self, datacenter_id, worker_id, sequence=0):
        """
        初始化
        :param datacenter_id: 数据中心（机器区域）ID
        :param worker_id: 机器ID
        :param sequence: 其实序号
        """
        # sanity check
        if worker_id > MAX_WORKER_ID or worker_id < 0:
            raise ValueError('worker_id值越界')

        if datacenter_id > MAX_DATACENTER_ID or datacenter_id < 0:
            raise ValueError('datacenter_id值越界')

        self.worker_id = worker_id
        self.datacenter_id = datacenter_id
        self.sequence = sequence

        self.last_timestamp = -1  # 上次计算的时间戳

    def _gen_timestamp(self):
        """
        生成整数时间戳
        :return:int timestamp
        """
        return int(time.time() * 1000)

    def get_id(self):
        """
        获取新ID
        :return:
        """
        timestamp = self._gen_timestamp()

        # 时钟回拨
        if timestamp < self.last_timestamp:
            raise InvalidSystemClock

        if timestamp == self.last_timestamp:
            self.sequence = (self.sequence + 1) & SEQUENCE_MASK
            if self.sequence == 0:
                timestamp = self._til_next_millis(self.last_timestamp)
        else:
            self.sequence = 0

        self.last_timestamp = timestamp

        new_id = ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) | (self.datacenter_id << DATACENTER_ID_SHIFT) | \
                 (self.worker_id << WOKER_ID_SHIFT) | self.sequence
        return new_id

    def _til_next_millis(self, last_timestamp):
        """
        等到下一毫秒
        """
        timestamp = self._gen_timestamp()
        while timestamp <= last_timestamp:
            timestamp = self._gen_timestamp()
        return timestamp


if __name__ == '__main__':
    worker = IdWorker(0, 0)
    print(worker.get_id())

Golang版本

/*

 * twitter雪花算法golang实现,生成唯一趋势自增id
 * 保留位:63位
 * 毫秒时间戳:[62-20]43位,时间范围[1970-01-01 00:00:00.000,2248-09-26 15:10:22.207]
 * 机器id:[19-12]8位,十进制范围[0,255]
 * 序列号:[11-0]12位,十进制范围[0,4095]
 * bobo
   */

package test

import (
    "runtime"
    "sync"
    "time"
)

type SnowFlake struct {
    machineID int64      //机器 id占8位,十进制范围是[0,255]
    sn        int64      //序列号占12位,十进制范围是[0,4095]
    lastTime  int64      //上次的时间戳(毫秒级)
    _lock     sync.Mutex //锁
}

var Snow = &SnowFlake{
    lastTime: time.Now().UnixNano() / 1000000,
}

func (c *SnowFlake) lock() {
    c._lock.Lock()
}

func (c *SnowFlake) unLock() {
    c._lock.Unlock()
}

//获取当前毫秒
func (c *SnowFlake) getCurMilliSecond() int64 {
    return time.Now().UnixNano() / 1000000
}

//设置机器id,默认为0,范围[0,255]
func (c *SnowFlake) SetMachineId(mId int64) {
    //保留8位
    mId = mId & 0xFF
    //左移12位,序列号是12位的
    mId <<= 12
    c.machineID = mId
}

//获取机器id
func (c *SnowFlake) GetMachineId() int64 {
    mId := c.machineID
    mId >>= 12
    return mId | 0xFF
}

//解析雪花(id)
// 返回值
// milliSecond:毫秒数
// mId:机器id
// sn:序列号
func (c *SnowFlake) ParseId(id int64) (milliSecond, mId, sn int64) {
    sn = id & 0xFFF
    id >>= 12
    mId = id & 0xFF
    id >>= 8
    milliSecond = id & 0x7FFFFFFFFFF

return

}

//毫秒转换成time
func (c *SnowFlake) MilliSecondToTime(milliSecond int64) (t time.Time) {
    return time.Unix(milliSecond/1000, milliSecond%1000*1000000)
}

//毫秒转换成"20060102T150405.999Z"
func (c *SnowFlake) MillisecondToTimeTz(ts int64) string {
    tm := Snow.MilliSecondToTime(ts)
    return tm.UTC().Format("20060102T150405.999Z")
}

//毫秒转换成"2006-01-02 15:04:05.999"
func (c *SnowFlake) MillisecondToTimeDb(ts int64) string {
    tm := Snow.MilliSecondToTime(ts)
    return tm.UTC().Format("2006-01-02 15:04:05.999")
}

//获取雪花
//返回值
//id:自增id
//ts:生成该id的毫秒时间戳
func (c *SnowFlake) GetSnowflakeId() (id, ts int64) {
    curTime := c.getCurMilliSecond()
    var sn int64 = 0

c.lock()
// 同一毫秒
if curTime == c.lastTime {
    c.sn++
    // 序列号占 12 位,十进制范围是 [0,4095]
    if c.sn > 4095 {
        for {
            // 让出当前线程
            runtime.Gosched()
            curTime = c.getCurMilliSecond()
            if curTime != c.lastTime {
                break
            }
        }
        c.sn = 0
    }
} else {
    c.sn = 0
}
sn = c.sn
c.lastTime = curTime
c.unLock()

//当前时间小于上次的时间，系统时间改过了吗?
/*
    if curTimeStamp < c.lastTimeStamp {
            return 0, curTimeStamp
    }
*/
//机器id占用8位空间,序列号占用12位空间,所以左移20位
rightBinValue := curTime & 0x7FFFFFFFFFF
rightBinValue <<= 20
id = rightBinValue | c.machineID | sn

return id, curTime

}

三、后语

简单介绍到此结束，代码实现部分来自网络。大伙周末愉快！

微信、知乎、简书、CSDN等平台搜索“道听真说”，点点关注不迷路！

如果本文对你有一点点帮助，请点个赞支持一下，谢谢啦:heart:

近期更新文章：

• 为什么我的数据库那么慢，教你提升10倍MySQL性能

• 安利Markdown文档编写利器Typora

• 高可用MySQL数据库之PXC集群