Distributed 分布式ID
需求背景
原本使用单机架构时，MySQL自带的InnoDB自增ID是没有任何问题的，但是随着数据量的日益增加，需要考虑到对单机架构做拆分扩展时，自带的ID方案便暴露出最基础的2个问题：
- 分库分表时可能会出现重复ID，造成主键冲突，但是我们需要的是大概率不会重复的ID，如订单号、货物号、信息号等等
- MySQL在处理数据的同时，还需要操心ID的生成，在高并发环境下压力会大一些，我们并不需要MySQL来生成ID，只负责数据的存读即可
因此我们需要设计一种新的ID生成方案。
设计原则
在设计分布式ID时，一定要遵从以下几点原则：
- 全局唯一：确保每个ID在分布式环境下各个节点中是唯一的
- 趋势递增：确保每个ID都是有序的，这更有利于InnoDB组织聚集索引
- 单调递增：确保下一个ID必须大于上一个ID
- 安全性：确保单从ID列不容易看出任何破绽，不会泄露业务信息
全局唯一
对于一些特定的数据，订单、流水等ID必须保证唯一，不会出现主键冲突。
这是分布式ID设计的最基础的原则，决不能违背。
趋势递增
有序的ID对InnoDB组织索引更加友好，因为InnoDB在组织索引时会将索引进行排序，而有序的ID可以避免InnoDB引擎在组织索引时进行二次排序，大量节约时间。
除此之外，在插入新的数据时，也不必麻烦InnoDB查询将要把该索引放置在那个位置上更加合适，而是直接放在上一个索引后面即可。
以此大幅度提高写入性能。
单调递增
保证下一个ID一定大于上一个ID，这在一些特殊场景下非常实用。
如对查询结果进行排序、单调递增可以使排序工作处理的更加迅速，而不用进行二次对比多次排序的情况。
安全性
单调的ID，如1、2、3、4等很容易被行内人看出一天的业务情况。
因此分布式ID设计时也要避免ID的单调性，设计的尽量不让人容易猜破。
设计思路
UUID
很多人可能马上会想到UUID，但是在了解设计原则后发现UUID并不是有序的，而是随机的，因此不大适合做分布式ID，但是也可以做。
优点总结：
- 性能高，不需要MySQL来生成ID，没有网络消耗
- 容易产生，ID唯一
缺点总结：
- 无法达到趋势递增、单调递增的需求，UUID是随机的
- 基于MAC地址生成UUID的算法可能会造成MAC地址泄露，这个漏洞曾被用于寻找梅丽莎病毒的制作者位置
- 不易于存储，UUID太长，16字节128位，很多场景不适用
Redis
Redis本身是单线程的处理，只要设计合理绝不会出现ID重复的现象。
如，订单号=日期+当日自增长号，可以每天在Redis中生成一个Key，使用INCR进行累加。
优点总结：
- 性能高，不依赖MySQL
- 容易产生，ID唯一
- 能够满足趋势递增、单调递增的需求
缺点总结：
- 依赖Redis，需要安装额外服务
- 编码和配置的工作量较大
其他方案?
如果你接触过MongoDB、Elasticsearch等分布式数据库，不知是否留意过它们的ID生成方案呢？
以MongoDB举例，共12个字节组成：
前4字节为Unix纪元开始的时间戳，单位为秒，这样会带来很多有用的属性：
- 时间戳与后5个字节（机器、进程号）组合起来，提供秒级别的唯一性
- 时间戳在前有一个好处，在下一个文档_id生成时会按照顺序进行排列插入，将其作为索引能提高查询效率
- 前4个字节隐含了该文档的创建时间，绝大多数驱动都会公开一个方法从objectId中获取这一信息
接下来的3字节为所在主机唯一标识符，由机器主机名散列值生成，可以确保不同主机生成的objectId不同
进程标识符（2字节）用来确保同一机器上多个进程产生的objectId是唯一的
计数器标识符（后3字节）是一个自增的计数器，用来确保相同进程同一秒中生成的objectId也不一样，同一秒钟最多允许每个进程产生256**3=16777216个不同的objectId
雪花算法
雪花算法与MongoDB的主键生成方案类似，不过更短，只需要64bit：
算法描述：
- 最高位是符号位，始终为0，不可用。
- 41位的时间序列，精确到毫秒级，41位的长度可以使用69年。时间位还有一个很重要的作用是可以根据时间进行排序。
- 10位的机器标识，10位的长度最多支持部署1024个节点。
- 12位的计数序列号，序列号即一系列的自增id，可以支持同一节点同一毫秒生成多个ID序号，12位的计数序列号支持每个节点每毫秒产生4096个ID序号。
41-bit的时间可以表示（1L<<41）/(1000L360024*365)=69年的时间，10-bit机器可以分别表示1024台机器。
如果我们对IDC划分有需求，还可以将10-bit分5-bit给IDC，分5-bit给工作机器。这样就可以表示32个IDC，每个IDC下可以有32台机器，可以根据自身需求定义。
12个自增序列号可以表示2^12个ID，理论上snowflake方案的QPS约为409.6w/s，这种分配方式可以保证在任何一个IDC的任何一台机器在任意毫秒内生成的ID都是不同的。
一句话总结，使用雪花算法可以达到69年内整个集群中的ID不会出现重复，是目前最主流的MySQL分布式ID生成方案。
优点总结：
- 毫秒数在高位，自增序列在低位，整个ID都是趋势递增的
- 不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的
- 可以根据自身业务特性分配bit位，非常灵活
缺点总结：
- 强依赖机器时钟，如果机器上时钟回拨，会导致发号重复或者服务会处于不可用状态。
常见代码
Python
Python版本的雪花算法方案代码：
#! /usr/local/bin/python3
# -*- 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())
使用时，只需要传入IDC的号码与机器号码即可。
Golang
Golang版本的雪花算法方案代码：
package main
import (
"errors"
"fmt"
"sync"
"time"
)
const (
workerBits uint8 = 10
numberBits uint8 = 12
workerMax int64 = -1 ^ (-1 << workerBits)
numberMax int64 = -1 ^ (-1 << numberBits)
timeShift uint8 = workerBits + numberBits
workerShift uint8 = numberBits
startTime int64 = 1525705533000 // 如果在程序跑了一段时间修改了epoch这个值 可能会导致生成相同的ID
)
type Worker struct {
mu sync.Mutex
timestamp int64
workerId int64
number int64
}
func NewWorker(workerId int64) (*Worker, error) {
if workerId < 0 || workerId > workerMax {
return nil, errors.New("Worker ID excess of quantity")
}
// 生成一个新节点
return &Worker{
timestamp: 0,
workerId: workerId,
number: 0,
}, nil
}
func (w *Worker) GetId() int64 {
w.mu.Lock()
defer w.mu.Unlock()
now := time.Now().UnixNano() / 1e6
if w.timestamp == now {
w.number++
if w.number > numberMax {
for now <= w.timestamp {
now = time.Now().UnixNano() / 1e6
}
}
} else {
w.number = 0
w.timestamp = now
}
ID := int64((now-startTime)<<timeShift | (w.workerId << workerShift) | (w.number))
return ID
}
func main() {
// 生成节点实例
node, err := NewWorker(1)
if err != nil {
panic(err)
}
for {
fmt.Println(node.GetId())
}
}
Java
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);
}
}
}
