项目场景:
分布式场景下保证id唯一性
问题描述
分部式集群环境下,存在大量数据需要分表分库时,使用数据库自增id不能唯一标识一条数据
解决方案:
目前已知的一些方案如下:
- UUID
- 数据库自增主键
- redis自增
- 雪花算法
UUID
通过代码生成16个随机字符
优点:生成的主键全局唯一;降低全局节点压力且生成速度块;跨服务器合并数据方便;
缺点:占用16个字符,占用空间较多;存储在mysql中时,因为不是有序数字,IO随机性大,索引效率下降;
示例代码:
/**
* 生成uuid
* @return
*/
public static String getUUID(){
return UUID.randomUUID().toString();
}
数据库自增主键
通过mysql单独建立序列表,给表建自增主键,或者直接在业务表上建立自增主键。
优点:int或者bigint类型占用空间小;自动递增,生成的id数据连续性好,且查询效率优于字符串。
缺点:并发性能不高(受限于mysql性能);如果分表分库,则需要改造;自增情况下,如果暴露id,则会导致数据量的泄露。
Redis自增(incr)
通过redis 计数器,原子性自增
优点:使用内存,并发性能好
缺点: 可能存在数据丢失;自增导致数据量泄露(针对自增,可以设置失效时间位1天,并且拼接日期作为唯一标识,这样可以只暴露当天最大数据量,减少影响。未验证过高并发下添加过期策略带来的影响)
代码如下:
public static Long incr(){
Long result = 0L;
String key = "autoKey";
String initialVue = "0";
boolean isBroken = false;
Jedis jedis = null;
try {
jedis = getJedis();
jedis.select(0);
String value = jedis.get(key);
if(StringUtils.isEmpty(value)){
jedis.set(key,initialVue);
}else{
result = jedis.incr(key);
}
} catch (Exception e) {
e.printStackTrace();
isBroken = true;
return null;
} finally {
closeResource(jedis, isBroken);
}
return result;
}
public static Long getRedisUUID(){
return RedisUtils.incr();
}
public static void main(String[] args) {
for (int i = 0;i< 10 ;i++){
new Thread(()->{
for (int j = 0;j< 10 ;j++){
System.out.println(getRedisUUID());
}
}).start();
}
}
执行结果(多打印几次 6-106 ):
雪花算法
组成:
- 符号位,占用1位
- 时间戳,占用41位,可以支持69年的时间跨度
- 机器id,占用10位
- 序列号,占用12位,一毫秒可以生成4095个id。超过4095个id时顺延到下一个时间戳
优点:不依赖外部组件;性能好
缺点(存在的问题):时钟回拨,不同服务器时间戳不一致导致id重复
代码如下:
import java.net.UnknownHostException;
/**
* 雪花算法实现
* - 符号位,占用1位
* - 时间戳,占用41位,可以支持69年的时间跨度
* - 机器id,占用10位
* - 序列号,占用12位,一毫秒可以生成4095个id。超过4095个id时顺延到下一个时间戳
* @author 联想
*/
public class SnowFlakeUtil {
// 机器ID 2进制5位 32位减掉1位 31个
private long workerId;
// 机器ID 2进制5位 32位减掉1位 31个
private long machineId;
//代表一毫秒内生成的多个id的最新序号 12位 4096 -1 = 4095 个
private long sequence;
//设置一个时间初始值 2^41 - 1 差不多可以用69年
private long twepoch = 1585644268888L;
//5位的机器id
private long workerIdBits = 5L;
//5位的机房id;。‘
private long datacenterIdBits = 5L;
//每毫秒内产生的id数 2 的 12次方
private long sequenceBits = 12L;
// 这个是二进制运算,就是5 bit最多只能有31个数字,也就是说机器id最多只能是32以内
private long maxWorkerId = -1L ^ (-1L << workerIdBits);
// 这个是一个意思,就是5 bit最多只能有31个数字,机房id最多只能是32以内
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
private long workerIdShift = sequenceBits;
private long datacenterIdShift = sequenceBits + workerIdBits;
private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
// -1L 二进制就是1111 1111 为什么?
// -1 左移12位就是 1111 1111 0000 0000 0000 0000
// 异或 相同为0 ,不同为1
// 1111 1111 0000 0000 0000 0000
// ^
// 1111 1111 1111 1111 1111 1111
// 0000 0000 1111 1111 1111 1111 换算成10进制就是4095
private long sequenceMask = -1L ^ (-1L << sequenceBits);
//记录产生时间毫秒数,判断是否是同1毫秒
private long lastTimestamp = -1L;
public long getWorkerId(){
return workerId;
}
public long getMachineId() {
return machineId;
}
public long getTimestamp() {
return System.currentTimeMillis();
}
public SnowFlakeUtil() {
}
public SnowFlakeUtil(long workerId, long datacenterId, long sequence) {
// 检查机房id和机器id是否超过31 不能小于0
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.machineId = datacenterId;
this.sequence = sequence;
}
// 这个是核心方法,通过调用nextId()方法,
// 让当前这台机器上的snowflake算法程序生成一个全局唯一的id
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));
}
// 下面是说假设在同一个毫秒内,又发送了一个请求生成一个id
// 这个时候就得把seqence序号给递增1,最多就是4096
if (timestamp == lastTimestamp) {
// 这个意思是说一个毫秒内最多只能有4096个数字,无论你传递多少进来,
//这个位运算保证始终就是在4096这个范围内,避免你自己传递个sequence超过了4096这个范围
sequence = (sequence + 1) & sequenceMask;
//当某一毫秒的时间,产生的id数 超过4095,系统会进入等待,直到下一毫秒,系统继续产生ID
if (sequence == 0) {
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0;
}
// 这儿记录一下最近一次生成id的时间戳,单位是毫秒
lastTimestamp = timestamp;
// 这儿就是最核心的二进制位运算操作,生成一个64bit的id
// 先将当前时间戳左移,放到41 bit那儿;将机房id左移放到5 bit那儿;将机器id左移放到5 bit那儿;将序号放最后12 bit
// 最后拼接起来成一个64 bit的二进制数字,转换成10进制就是个long型
return ((timestamp - twepoch) << timestampLeftShift) |
(machineId << datacenterIdShift) |
(workerId << workerIdShift) | sequence;
}
/**
* 当某一毫秒的时间,产生的id数 超过4095,系统会进入等待,直到下一毫秒,系统继续产生ID
* @param lastTimestamp
* @return
*/
private long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
/**
* 获取当前时间戳
*/
private long timeGen(){
return System.currentTimeMillis();
}
public static void main(String[] args) throws UnknownHostException {
// 验证一秒能生成多少个id
SnowFlakeUtil snowFlakeUtil = new SnowFlakeUtil(1,1,1);
long start = System.currentTimeMillis();
int i = 0;
for (; System.currentTimeMillis()-start < 1000; i++) {
snowFlakeUtil.nextId();
}
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start));
System.out.println("生成id个数:"+i);
}
}