一、简介
1、雪花算法的组成：
由64个Bit(比特)位组成的long类型的数字
0 | 0000000000 0000000000 0000000000 000000000 | 00000 | 00000 | 000000000000
1个bit：符号位，始终为0。
41个bit：时间戳，精确到毫秒级别，可以使用69年。
10个bit：工作机器ID，可以部署在1024个节点上。
12个bit：序列号，每个节点每毫秒内最多可以生成4096个ID。
2、雪花算法的优缺点
优点：
全局唯一：雪花算法生成的ID是全局唯一的，可以用于分布式系统中的数据分片和数据合并。
时间有序：雪花算法生成的ID中包含了时间戳信息，可以根据ID的大小推算出生成的时间。
高性能：雪花算法生成ID的速度很快，可以满足高并发的场景需求。
可扩展性：雪花算法的数据结构相对简单，易于扩展和修改。
缺点：
依赖于系统时钟：雪花算法生成ID的过程中依赖于系统时钟，如果系统时钟发生回拨，可能会导致生成的ID出现重复。
长度固定：雪花算法生成的ID长度固定为64位，可能会导致存储和传输成本较高。
不支持分布式计算：雪花算法生成ID的过程是单线程的，不能支持分布式计算。文章来源：https://www.toymoban.com/news/detail-677001.html
二、项目中使用
1、引入依赖
https://www.hutool.cn/文章来源地址https://www.toymoban.com/news/detail-677001.html
<!-- 雪花算法生成UUID的相关依赖 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-core</artifactId>
<version>5.8.20</version>
</dependency>
2、使用
//生成带-的UUID字符串
System.out.println(IdUtil.randomUUID());
//生成不带-的UUID字符串
System.out.println(IdUtil.simpleUUID());
//使用雪花算法生成id
System.out.println(IdUtil.getSnowflake(0,0).nextId());
//使用雪花算法生成id，返回字符串类型
System.out.println(IdUtil.getSnowflake(1,1).nextIdStr());
System.out.println(IdUtil.getSnowflake(1,1).nextIdStr());
System.out.println(IdUtil.getSnowflake(2,1).nextIdStr());
System.out.println(IdUtil.getSnowflake(2,1).nextIdStr());
三、手写雪花算法生成ID
import java.util.Date;
public class SnowFlakeUtil {
private static SnowFlakeUtil snowFlakeUtil;
static {
snowFlakeUtil = new SnowFlakeUtil();
}
// 初始时间戳(纪年)，可用雪花算法服务上线时间戳的值
// 1650789964886：2022-04-24 16:45:59
private static final long INIT_EPOCH = 1650789964886L;
// 时间位取&
private static final long TIME_BIT = 0b1111111111111111111111111111111111111111110000000000000000000000L;
// 记录最后使用的毫秒时间戳，主要用于判断是否同一毫秒，以及用于服务器时钟回拨判断
private long lastTimeMillis = -1L;
// dataCenterId占用的位数
private static final long DATA_CENTER_ID_BITS = 5L;
// dataCenterId占用5个比特位，最大值31
// 0000000000000000000000000000000000000000000000000000000000011111
private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
// dataCenterId
private long dataCenterId;
// workId占用的位数
private static final long WORKER_ID_BITS = 5L;
// workId占用5个比特位，最大值31
// 0000000000000000000000000000000000000000000000000000000000011111
private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
// workId
private long workerId;
// 最后12位，代表每毫秒内可产生最大序列号，即 2^12 - 1 = 4095
private static final long SEQUENCE_BITS = 12L;
// 掩码（最低12位为1，高位都为0），主要用于与自增后的序列号进行位与，如果值为0，则代表自增后的序列号超过了4095
// 0000000000000000000000000000000000000000000000000000111111111111
private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);
// 同一毫秒内的最新序号，最大值可为 2^12 - 1 = 4095
private long sequence;
// workId位需要左移的位数 12
private static final long WORK_ID_SHIFT = SEQUENCE_BITS;
// dataCenterId位需要左移的位数 12+5
private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
// 时间戳需要左移的位数 12+5+5
private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;
/**
* 无参构造
*/
public SnowFlakeUtil() {
this(1, 1);
}
/**
* 有参构造
*/
public SnowFlakeUtil(long dataCenterId, long workerId) {
// 检查dataCenterId的合法值
if (dataCenterId < 0 || dataCenterId > MAX_DATA_CENTER_ID) {
throw new IllegalArgumentException(
String.format("dataCenterId 值必须大于 0 并且小于 %d", MAX_DATA_CENTER_ID));
}
// 检查workId的合法值
if (workerId < 0 || workerId > MAX_WORKER_ID) {
throw new IllegalArgumentException(String.format("workId 值必须大于 0 并且小于 %d", MAX_WORKER_ID));
}
this.workerId = workerId;
this.dataCenterId = dataCenterId;
}
/**
* 获取唯一ID
*/
public static Long getSnowFlakeId() {
return snowFlakeUtil.nextId();
}
/**
* 通过雪花算法生成下一个id，用synchronized同步
*/
public synchronized long nextId() {
long currentTimeMillis = System.currentTimeMillis();
System.out.println(currentTimeMillis);
// 当前时间小于上一次生成id使用的时间，可能出现服务器时钟回拨问题
if (currentTimeMillis < lastTimeMillis) {
throw new RuntimeException(
String.format("可能出现服务器时钟回拨问题，请检查服务器时间。当前服务器时间戳：%d，上一次使用时间戳：%d", currentTimeMillis,
lastTimeMillis));
}
if (currentTimeMillis == lastTimeMillis) {
// 还是在同一毫秒内，则将序列号递增1，序列号最大值为4095
// 序列号的最大值是4095，使用掩码（最低12位为1，高位都为0）进行位与运行后如果值为0，则自增后的序列号超过了4095
// 那么就使用新的时间戳
sequence = (sequence + 1) & SEQUENCE_MASK;
if (sequence == 0) {
currentTimeMillis = getNextMillis(lastTimeMillis);
}
} else { // 不在同一毫秒内，则序列号重新从0开始，序列号最大值为4095
sequence = 0;
}
// 记录最后一次使用的毫秒时间戳
lastTimeMillis = currentTimeMillis;
// 核心算法，将不同部分的数值移动到指定的位置，然后进行或运行
// <<：左移运算符, 1 << 2 即将二进制的 1 扩大 2^2 倍
// |：位或运算符, 是把某两个数中, 只要其中一个的某一位为1, 则结果的该位就为1
// 优先级：<< > |
return
// 时间戳部分
((currentTimeMillis - INIT_EPOCH) << TIMESTAMP_SHIFT)
// 数据中心部分
| (dataCenterId << DATA_CENTER_ID_SHIFT)
// 机器表示部分
| (workerId << WORK_ID_SHIFT)
// 序列号部分
| sequence;
}
/**
* 获取指定时间戳的接下来的时间戳，也可以说是下一毫秒
* @param lastTimeMillis 指定毫秒时间戳
* @return 时间戳
*/
private long getNextMillis(long lastTimeMillis) {
long currentTimeMillis = System.currentTimeMillis();
while (currentTimeMillis <= lastTimeMillis) {
currentTimeMillis = System.currentTimeMillis();
}
return currentTimeMillis;
}
/**
* 获取随机字符串,length=13
*/
public static String getRandomStr() {
return Long.toString(getSnowFlakeId(), Character.MAX_RADIX);
}
/**
* 从ID中获取时间
* @param id 由此类生成的ID
*/
public static Date getTimeBySnowFlakeId(long id) {
return new Date(((TIME_BIT & id) >> 22) + INIT_EPOCH);
}
public static void main(String[] args) {
SnowFlakeUtil snowFlakeUtil = new SnowFlakeUtil();
long id = snowFlakeUtil.nextId();
System.out.println("id: "+id);
Date date = SnowFlakeUtil.getTimeBySnowFlakeId(id);
System.out.println("date: "+date);
long time = date.getTime();
System.out.println("time: "+time);
System.out.println("getRandomStr: "+getRandomStr());
}
}到了这里，关于分布式—雪花算法生成ID的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
