目录
问题需求
在数据库中需要插入一个唯一性的标识，常用目前处理方案
1，使用UUID
UUID(Universally Unique ldentifer)的标准型式包含32个16进制数字，以连了号分为五段，形式为8-4-4-4-12的36个字符， 示例：550e8400-e29b-41d4-a716-446655440000
public class UUIDTest {
public static void main(String[] args) {
System.out.println(UUID.randomUUID().toString());
}
}
性能非常高：本地生成，没有网络消耗
如果只是考虑唯一性，那就选用它吧
但是，入数据库性能差
为什么无序的UUID会导致入库性能变差呢？
无序，无法预测他的生成顺序，不能生成递增有序的数字。首先分布式ID一般都会作为主键， 但是安装MySQL官方推荐主键要尽量越短越好，UUID每一个都很长，所以不是很推荐。
主键，ID作为主键时在特定的环境会存在一些问题。比如做DB主键的场景下，UUID就非常不适用MySQL官方有明确的建议主键要尽量越短越好36个字符长度的UUID不符合要求。
索引，既然分布式ID是主键，然后主键是包含索引的，然后MySQL的索引是通过B+树来实现的，每一次新的UUID数据的插入，为了查询的优化，都会对索引底层的B+树进行修改，因为UUID数据是无序的，所以每一次UUID数据的插入都会对主键地械的B+树进行很大的修改，这一点很不好。 插入完全无序，不但会导致一-些中间节点产生分裂，也会白白创造出很多不饱和的节点，这样大大降低了数据库插入的性能。
2，数据库自增主键
单机
在单机里面，数据库的自增ID机制的主要原理是：数据库自增ID和MySQL数据库的replace into实现的。
REPLACE INTO的含义是插入一条记录，如果表中唯一索引的值遇到冲突，则替换老数据。
这里的replace into跟inset功能类似，不同点在于：replace into首先尝试插入数据列表中，如果发现表中已经有此行数据（根据主键或唯一索引判断）则先删除，再插入。否则直接插入新数据。
CREATE TABLE t_test(
id BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
stub CHAR(1) NOT NULL DEFAULT '',
UNIQUE KEY stub(stub)
)
SELECT * FROMt_ test;
REPLACE INTO t_test (stub) VALUES('b');
SELECT LAST_INSERT_ID();集群分布式
那数据库自增ID机制适合作分布式ID吗？答案是不太适合
1：系统水平扩展比较困难，比如定义好了步长和机器台数之后，如果要添加机器该怎么做？假设现在只有一台机器发号是1，2，3，4，5（步长是1），这
个时候需要扩容机器一台。可以这样做：把第二台机器的初始值设置得比第一台超过很多，貌似还好，现在想象一下如果我们线上有100台机器，这
个时候要扩容该怎么做？简直是噩梦，所以系统水平扩展方案复杂难以实现。
2：数据库压力还是很大，每次获取ID都得读写一次数据库， 非常影响性能，不符合分布式ID里面的延迟低和要高QPS的规则（在高并发下，如果都去数据库里面获取id，那是非常影响性能的）
3，基于Redis生成全局ID策略
因为Redis是单线的天生保证原子性，可以使用原子操作INCR和INCRBY来实现
注意：在Redis集群情况下，同样和MySQL一样需要设置不同的增长步长，同时key一定要设置有效期可以使用Redis集群来获取更高的吞吐量。
假如一个集群中有5台Redis。可以初始化每台Redis的值分别是1,2,3,4,5，然后步长都是5。虽然可以实现 但是需要维护reids的集群
各个Redis生成的ID为:
A：1, 6, 11, 16, 21
B：2, 7 , 12, 17, 22
C：3, 8, 13, 18, 23
D：4, 9, 14, 19, 24
E：5, 10, 15, 20, 25
4，雪花算法
在分布式的环境下必须全局且唯一 。
- 一般都需要单调递增，因为一般唯一ID都会存到数据库，而Innodb的特性就是将内容存储在主键索引树上的叶子节点而且是从左往右，递增的，所以考
- 虑到数据库性能，一般生成的ID也最好是单调递增。 为了防止ID冲突可以使用36位的UUID，但是UUID有一些缺点， 首先他相对比较长， 另外UUID一般是无序的。
- 可能还会需要无规则，因为如果使用唯一ID作为订单号这种，为了不然别人知道一天的订单量是多少，就需要这个规则。
雪花算法结构
雪花算法的几个核心组成部分：
号段解析
1bit：
不用，因为二进制中最高位是符号位，1表示负数，0表示正数。生成的id一般都是用整数，所以最高位固定为0。
41bit - 时间戳，用来记录时间戳，毫秒级：
- 41位可以表示为2的41次方减去1个数字2^{41}-1
- 如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是0到0至 2^{41}-1 ，减1是因为可表示的数值范围是从0开始算的，而不是1。
- 也就是说41位可以表示 2^{41}-1个毫秒的值，转化成单位年则是（2^{41}-1）/ (1000∗60∗60∗24∗365)=69年。
10bit - 工作机器ID，用来记录工作机器ID：
- 可以部署 2^{10}= 10242 个节点，包括5位DataCenterId和5位Workerld。
- 5位(bit) 可以表示的最大正整数是 2^{5}−1=31,即可以用0、1、2、3、…31这32个数字，来表示不同的DataCenterld或Workerld。
注意：我们在分布式中保证雪花算法生成的id不一致，主要就是就是依据DataCenterld和Workerld，后续会用到。
12bit - 序列号，用来记录同毫秒内产生的不同id。
12位(bit) 可以表示的最大正整数是 2^{12} - 1 = 40952 ，即可以用0、1、2、 3、…4094这4095个数字，来表示同一机器同一时间截(毫秒)内产生的4095个ID序号。
SnowFlake可以保证：
所有生成的ID按时间趋势递增。
整个分布式系统内不会产生重复id（因为有DataCenterId和Workerld来做区分)
优缺点
优点：
毫秒数在高位，自增序列在低位，整个ID都是趋势递增的。
不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的。
可以根据自身业务特性分配bit位，非常灵活。
缺点：
依赖机器时钟，如果机器时钟回拨，会导致重复ID生成。
在单机上是递增的，但是由于设计到分布式环境，每台机器上的时钟不可能完全同步，有时候会出现不是全局递增的情况。
（此缺点可以认为无所谓，一般分布式ID只要求趋势递增，并不会严格要求递增，90%的需求都只要求趋势递增）
源码以下代码仅供学习
/**
* Twitter_Snowflake
* SnowFlake的结构如下(每部分用-分开):
* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
* 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
* 41位时间戳(毫秒级)，注意，41位时间戳不是存储当前时间的时间戳，而是存储时间戳的差值（当前时间戳 - 开始时间戳)
* 得到的值），这里的的开始时间戳，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下面程序SnowflakeIdWorker类的startTime属性）。41位的时间戳，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69
* 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间戳)产生4096个ID序号
* 加起来刚好64位，为一个Long型。
*/
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;
//==============================Constructors=====================================
/**
* 构造函数
* @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;
}
// ==============================Methods==========================================
/**
* 获得下一个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) {
System.out.println("开始："+System.currentTimeMillis());
SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
for (int i = 0; i < 50; i++) {
long id = idWorker.nextId();
System.out.println(id);
// System.out.println(Long.toBinaryString(id));
}
System.out.println("结束："+System.currentTimeMillis());
}
}
雪花算法应用改进
从上面的源码我们可以看的出来，每次在生成id的时候需要手动的指定工作id和机器id两个值，如果我们的服务部署在两台不同的服务器上面，并且两台服务器上面的服务，生成的id值都放在了同一张表示表中（分布式），而且还要保证唯一（作为主键使用），那么我们的机器id和工作id就不能保持一致，以此来保证id的唯一性，因此我们要在每一个服务器上面确定不一样的DataCenterld和Workerld
解决方案1
我们可以把DataCenterld和Workerld值放在配置文件中，然后手动获取值（实现比较简单，代码就不贴出来了）
解决方案2
我们可以获取到当前服务器的地址作为DataCenterld，我们获取到当前服务器的名称作为Workerld
代码如下：
package com.asinfo.config;
import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.slf4j.LoggerFactory;
import java.net.Inet4Address;
import java.net.UnknownHostException;
public class SnowflakeIdWorker {
// ==============================Fields===========================================
/** 开始时间截 (2015-01-01) */
//private final long twepoch = 1489111610226L;
private final long twepoch = 1665568007832L;
/** 机器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;
private static SnowflakeIdWorker idWorker;
static {
//获取id之前给工作机器ID和数据中心ID赋值
idWorker = new SnowflakeIdWorker(getWorkId(),getDataCenterId());
//idWorker = new SnowflakeIdWorker(33,33);
}
//==============================Constructors=====================================
/**
* 构造函数
* @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("workerId can't be greater than %d or less than 0", maxWorkerId));
}
if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
throw new IllegalArgumentException(String.format("dataCenterId can't be greater than %d or less than 0", maxDataCenterId));
}
//将值赋值给全量
this.workerId = workerId;
this.dataCenterId = dataCenterId;
}
// ==============================Methods==========================================
/**
* 获得下一个ID (该方法是线程安全的)
* @return SnowflakeId
*/
public synchronized long nextId() {
//获取到当前时间戳
long timestamp = timeGen();
System.out.println("当前时间戳"+timestamp);
System.out.println("上一次的时间戳="+lastTimestamp);
//如果当前时间小于上一次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();
}
private static Long getWorkId(){
try {
String hostAddress = Inet4Address.getLocalHost().getHostAddress();
int[] ints = StringUtils.toCodePoints(hostAddress);
int sums = 0;
for(int b : ints){
sums += b;
}
return (long)(sums % 32);
} catch (UnknownHostException e) {
// 如果获取失败，则使用随机数备用
return RandomUtils.nextLong(0,31);
}
}
private static Long getDataCenterId(){
int[] ints = StringUtils.toCodePoints(SystemUtils.getHostName());
int sums = 0;
for (int i: ints) {
sums += i;
}
return (long)(sums % 32);
}
/**
* 静态工具类
*
* @return
*/
public static synchronized Long generateId(){
//获取到当前id值
long id = idWorker.nextId();
return id;
}
//==============================Test=============================================
/** 测试 */
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());
long startTime = System.nanoTime();
for (int i = 0; i < 50; i++) {
long id = SnowflakeIdWorker.generateId();
System.out.println(id);
}
System.out.println((System.nanoTime()-startTime)/1000000+"ms");
}
}
解决方案3
使用hutool工具
添加依赖
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.1.0</version>
</dependency>创建一个service层，创建一个接口，和一个实体类，用来完成雪花算法的实现调用
IdGeneratorSnowflake类
@Slf4j
@Component
public class IdGeneratorSnowflake {
//定义机房的位置 范围是 0~31
private long workerId=0;
//定义机房的机器编号 范围是 0~31
private long datacneterId=1;
private Snowflake snowflake= IdUtil.createSnowflake(workerId,datacneterId);
//使用这个注解完成加载初始化的工作
@PostConstruct
public void init(){
//获取当前机器的workId
try {
workerId= NetUtil.ipv4ToLong(NetUtil.getLocalhostStr());
log.info("当前机器的workId是:{}",workerId);
} catch (Exception e) {
e.printStackTrace();
log.info("当前机器的workId获取失败",e);
workerId=NetUtil.getLocalhostStr().hashCode();
}
}
public synchronized long snowflakeId( ) {
return snowflake.nextId();
}
public synchronized long snowflakeId(long workerId,long datacneterId) {
Snowflake snowflake=IdUtil.createSnowflake(workerId,datacneterId);
return snowflake.nextId();
}
public static void main(String[] args) {
IdGeneratorSnowflake idGenerator = new IdGeneratorSnowflake();
System.out.println(idGenerator.snowflakeId());
}
}SnowFlakeService类
@Component
public class SnowFlakeService {
//依赖注入实现获得值得类
@Resource
private IdGeneratorSnowflake idGeneratorSnowflake;
public String getIDBySnowflake(){
ExecutorService executorService=null;
try {
//创建一个线程池
executorService =Executors.newFixedThreadPool(5);
//设置线程池的任务
for (int i=0;i<20;i++){
executorService.submit(()->{
//这个20个线程都要获得雪花算法的值
System.out.println(idGeneratorSnowflake.snowflakeId());
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭线程池
executorService.shutdown();
}
return "hello sonwflake";
}
}创建一个controller包
@RestController
public class SnowflakeController {
@Resource
private SnowFlakeService service;
@GetMapping("/snowflake")
public String getSnowflake(){
return service.getIDBySnowflake();
}
}创建主启动类
@RestController
public class SnowflakeController {
@Resource
private SnowFlakeService service;
@GetMapping("/snowflake")
public String getSnowflake(){
return service.getIDBySnowflake();
}
}
5695
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
