使用uuid作为数据库主键，被技术总监怼了一顿！

看完本文，你一定会有所收获

一、摘要

在日常开发中，数据库中主键id的生成方案，主要有三种

  • 数据库自增ID

  • 采用随机数生成不重复的ID

  • 采用jdk提供的uuid

对于这三种方案，我发现在数据量少的情况下，没有特别的差异，但是当单表的数据量达到百万级以上时候，他们的性能有着显著的区别，光说理论不行，还得看实际程序测试，今天小编就带着大家一探究竟！

二、程序实例

首先，我们在本地数据库中创建三张单表tb_uuid_1、tb_uuid_2、tb_uuid_3，同时设置tb_uuid_1表的主键为自增长模式，脚本如下：

1
2
3
4
5
CREATETABLE`tb_uuid_1`(
`id`bigint(20)unsignedNOTNULLAUTO_INCREMENT,
`name`varchar(20)DEFAULTNULL,
PRIMARYKEY(`id`)
)ENGINE=InnoDBDEFAULTCHARSET=utf8mb4COLLATE=utf8mb4_unicode_ciCOMMENT='主键ID自增长';

1
2
3
4
5
CREATETABLE`tb_uuid_2`(
`id`bigint(20)unsignedNOTNULL,
`name`varchar(20)DEFAULTNULL,
PRIMARYKEY(`id`)
)ENGINE=InnoDBDEFAULTCHARSET=utf8mb4COLLATE=utf8mb4_unicode_ciCOMMENT='主键ID随机数生成';

1
2
3
4
5
CREATETABLE`tb_uuid_3`(
`id`varchar(50)NOTNULL,
`name`varchar(20)DEFAULTNULL,
PRIMARYKEY(`id`)
)ENGINE=InnoDBDEFAULTCHARSET=utf8mb4COLLATE=utf8mb4_unicode_ciCOMMENT='主键采用uuid生成';

下面，我们采用Springboot + mybatis来实现插入测试。

2.1、数据库自增

以数据库自增为例，首先编写好各种实体、数据持久层操作，方便后续进行测试

1
2
3
4
5
6
7
8
9
10
11
/**
* 表实体
*/
publicclassUUID1implementsSerializable{
privateLongid;
privateStringname;
//省略set、get
}

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 数据持久层操作
*/
publicinterfaceUUID1Mapper{
/**
* 自增长插入
* @param uuid1
*/
@Insert("INSERT INTO tb_uuid_1(name) VALUES(#{name})")
voidinsert(UUID1uuid1);
}

1
2
3
4
5
6
7
8
9
10
11
12
/**
* 自增ID，单元测试
*/
@Test
publicvoidtestInsert1(){
longstart=System.currentTimeMillis();
for(inti=0;i<1000000;i++){
uuid1Mapper.insert(newUUID1().setName("张三"));
}
longend=System.currentTimeMillis();
System.out.println("花费时间："+(end-start));
}

2.2、采用随机数生成ID

这里，我们采用twitter的雪花算法来实现随机数ID的生成，工具类如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
publicclassSnowflakeIdWorker{
privatestaticSnowflakeIdWorkerinstance=newSnowflakeIdWorker(0,0);
/**
* 开始时间截 (2015-01-01)
*/
privatefinallongtwepoch=1420041600000L;
/**
* 机器id所占的位数
*/
privatefinallongworkerIdBits=5L;
/**
* 数据标识id所占的位数
*/
privatefinallongdatacenterIdBits=5L;
/**
* 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
*/
privatefinallongmaxWorkerId=-1L^(-1L<<workerIdBits);
/**
* 支持的最大数据标识id，结果是31
*/
privatefinallongmaxDatacenterId=-1L^(-1L<<datacenterIdBits);
/**
* 序列在id中占的位数
*/
privatefinallongsequenceBits=12L;
/**
* 机器ID向左移12位
*/
privatefinallongworkerIdShift=sequenceBits;
/**
* 数据标识id向左移17位(12+5)
*/
privatefinallongdatacenterIdShift=sequenceBits+workerIdBits;
/**
* 时间截向左移22位(5+5+12)
*/
privatefinallongtimestampLeftShift=sequenceBits+workerIdBits+datacenterIdBits;
/**
* 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
*/
privatefinallongsequenceMask=-1L^(-1L<<sequenceBits);
/**
* 工作机器ID(0~31)
*/
privatelongworkerId;
/**
* 数据中心ID(0~31)
*/
privatelongdatacenterId;
/**
* 毫秒内序列(0~4095)
*/
privatelongsequence=0L;
/**
* 上次生成ID的时间截
*/
privatelonglastTimestamp=-1L;
/**
* 构造函数
* @param workerId     工作ID (0~31)
* @param datacenterId 数据中心ID (0~31)
*/
publicSnowflakeIdWorker(longworkerId,longdatacenterId){
if(workerId>maxWorkerId||workerId<0){
thrownewIllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0",maxWorkerId));
}
if(datacenterId>maxDatacenterId||datacenterId<0){
thrownewIllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0",maxDatacenterId));
}
this.workerId=workerId;
this.datacenterId=datacenterId;
}
/**
* 获得下一个ID (该方法是线程安全的)
* @return SnowflakeId
*/
publicsynchronizedlongnextId(){
longtimestamp=timeGen();
// 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
if(timestamp<lastTimestamp){
thrownewRuntimeException(
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 当前时间戳
*/
protectedlongtilNextMillis(longlastTimestamp){
longtimestamp=timeGen();
while(timestamp<=lastTimestamp){
timestamp=timeGen();
}
returntimestamp;
}
/**
* 返回以毫秒为单位的当前时间
* @return 当前时间(毫秒)
*/
protectedlongtimeGen(){
returnSystem.currentTimeMillis();
}
publicstaticSnowflakeIdWorkergetInstance(){
returninstance;
}
publicstaticvoidmain(String[]args)throwsInterruptedException{
SnowflakeIdWorkeridWorker=SnowflakeIdWorker.getInstance();
for(inti=0;i<10;i++){
longid=idWorker.nextId();
Thread.sleep(1);
System.out.println(id);
}
}
}

其他的操作，与上面类似。

2.3、uuid

同样的，uuid的生成，我们事先也可以将工具类编写好：

1
2
3
4
5
6
7
8
9
10
publicclassUUIDGenerator{
/**
* 获取uuid
* @return
*/
publicstaticStringgetUUID(){
returnUUID.randomUUID().toString();
}
}

最后的单元测试，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
@RunWith(SpringRunner.class)
@SpringBootTest()
publicclassUUID1Test{
privatestaticfinalIntegerMAX_COUNT=1000000;
@Autowired
privateUUID1Mapperuuid1Mapper;
@Autowired
privateUUID2Mapperuuid2Mapper;
@Autowired
privateUUID3Mapperuuid3Mapper;
/**
* 测试自增ID耗时
*/
@Test
publicvoidtestInsert1(){
longstart=System.currentTimeMillis();
for(inti=0;i<MAX_COUNT;i++){
uuid1Mapper.insert(newUUID1().setName("张三"));
}
longend=System.currentTimeMillis();
System.out.println("自增ID，花费时间："+(end-start));
}
/**
* 测试采用雪花算法生产的随机数ID耗时
*/
@Test
publicvoidtestInsert2(){
longstart=System.currentTimeMillis();
for(inti=0;i<MAX_COUNT;i++){
longid=SnowflakeIdWorker.getInstance().nextId();
uuid2Mapper.insert(newUUID2().setId(id).setName("张三"));
}
longend=System.currentTimeMillis();
System.out.println("花费时间："+(end-start));
}
/**
* 测试采用UUID生成的ID耗时
*/
@Test
publicvoidtestInsert3(){
longstart=System.currentTimeMillis();
for(inti=0;i<MAX_COUNT;i++){
Stringid=UUIDGenerator.getUUID();
uuid3Mapper.insert(newUUID3().setId(id).setName("张三"));
}
longend=System.currentTimeMillis();
System.out.println("花费时间："+(end-start));
}
}

三、性能测试

程序环境搭建完成之后，啥也不说了，直接撸起袖子，将单元测试跑起来！

首先测试一下，插入100万数据的情况下，三者直接的耗时结果如下：

在原有的数据量上，我们继续插入30万条数据，三者耗时结果如下：

可以看出在数据量 100W 左右的时候，uuid的插入效率垫底，随着插入的数据量增长，uuid 生成的ID插入呈直线下降！

时间占用量总体效率排名为：自增ID > 雪花算法生成的ID » uuid生成的ID。

在数据量较大的情况下，为什么uuid生成的ID远不如自增ID呢？

关于这点，我们可以从 mysql 主键存储的内部结构来进行分析。

3.1、自增ID内部结构

自增的主键的值是顺序的，所以 Innodb 把每一条记录都存储在一条记录的后面。

使用uuid作为数据库主键，被技术总监怼了一顿！

当达到页面的最大填充因子时候(innodb默认的最大填充因子是页大小的15/16,会留出1/16的空间留作以后的修改)，会进行如下操作：

  • 下一条记录就会写入新的页中，一旦数据按照这种顺序的方式加载，主键页就会近乎于顺序的记录填满，提升了页面的最大填充率，不会有页的浪费

  • 新插入的行一定会在原有的最大数据行下一行，mysql定位和寻址很快，不会为计算新行的位置而做出额外的消耗

3.2、使用uuid的索引内部结构

uuid相对顺序的自增id来说是毫无规律可言的，新行的值不一定要比之前的主键的值要大，所以innodb无法做到总是把新行插入到索引的最后，而是需要为新行寻找新的合适的位置从而来分配新的空间。

使用uuid作为数据库主键，被技术总监怼了一顿！

这个过程需要做很多额外的操作，数据的毫无顺序会导致数据分布散乱，将会导致以下的问题：

  • 写入的目标页很可能已经刷新到磁盘上并且从缓存上移除，或者还没有被加载到缓存中，innodb在插入之前不得不先找到并从磁盘读取目标页到内存中，这将导致大量的随机IO

  • 因为写入是乱序的,innodb不得不频繁的做页分裂操作,以便为新的行分配空间,页分裂导致移动大量的数据，一次插入最少需要修改三个页以上

  • 由于频繁的页分裂，页会变得稀疏并被不规则的填充，最终会导致数据会有碎片

在把值载入到聚簇索引(innodb默认的索引类型)以后，有时候会需要做一次OPTIMEIZE TABLE来重建表并优化页的填充，这将又需要一定的时间消耗。

因此，在选择主键ID生成方案的时候，尽可能别采用uuid的方式来生成主键ID，随着数据量越大，插入性能会越低！

四、总结

在实际使用过程中，推荐使用主键自增ID和雪花算法生成的随机ID。

但是使用自增ID也有缺点：

1、别人一旦爬取你的数据库，就可以根据数据库的自增id获取到你的业务增长信息，很容易进行数据窃取。

2、其次，对于高并发的负载，innodb在按主键进行插入的时候会造成明显的锁争用，主键的上界会成为争抢的热点，因为所有的插入都发生在这里，并发插入会导致间隙锁竞争。

总结起来，如果业务量小，推荐采用自增ID，如果业务量大，推荐采用雪花算法生成的随机ID。

本篇文章主要从实际程序实例出发，讨论了三种主键ID生成方案的性能差异，

鉴于笔者才疏学浅，可能也有理解不到位的地方，欢迎网友们批评指出！

五、参考

1、方志明 - 使用雪花id或uuid作为Mysql主键，被老板怼了一顿！

以上是 使用uuid作为数据库主键，被技术总监怼了一顿！ 的全部内容， 来源链接： utcz.com/a/129926.html

回到顶部