数据库主键到底是用自增长（INT）好还是UUID好？

数据库主键到底是用自增长（INT）好还是UUID好？

使用自增长做主键的优点：
1、很小的数据存储空间
2、性能最好
3、容易记忆
使用自增长做主键的缺点：
1、如果存在大量的数据，可能会超出自增长的取值范围
2、很难（并不是不能）处理分布式存储的数据表，尤其是需要合并表的情况下
3、安全性低，因为是有规律的，容易被非法获取数据
使用UUID做主键的优点：
1、它是独一无二的，出现重复的机会少
2、适合大量数据中的插入和更新操作，尤其是在高并发和分布式环境下
3、跨服务器数据合并非常方便
4、安全性较高
使用UUID做主键的缺点：
1、存储空间大（16 byte），因此它将会占用更多的磁盘空间
2、会降低性能
3、很难记忆

那么一般情况下是如何选择的呢？

1、项目是单机版的，并且数据量比较大（百万级）时，用自增长的，此时最好能考虑下安全性，做些安全措施。
2、项目是单机版的，并且数据量没那么大，对速度和存储要求不高时，用UUID。
3、项目是分布式的，那么首选UUID，分布式一般对速度和存储要求不高。
4、项目是分布式的，并且数据量达到千万级别可更高时，对速度和存储有要求时，可以用自增长。

总体对比来看自增长相对来说在较大的项目中是首选，那么有没有一更优于自增长的方法呢？答案在↓边！

SnowFlake是一种介于自增长和UUID之间的一种主键（存储空间小、速度快、分布式、时间序列）它有如下优点

1.所有生成的id按时间趋势递增
2.整个分布式系统内不会产生ID碰撞（重复id，因为有datacenterId和workerId来做区分）
3.id生成的效率高

SnowFlake算法生成id的结果是一个64bit大小的整数,一般用户分布式环境的id生成下面我们来看一下SnowFlake生成的id的结构

第一段占1位

固定值0。二进制中最高位为1的都是负数，但是我们生成的id一般都使用整数，所以这个最高位固定是0

第二段占41位

用来记录时间戳（毫秒）。41位可以表示$2^{41}-1$个数字，
如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是：0 至 $2^{41}-1$，减1是因为可表示的数值范围是从0开始算的，而不是1。
也就是说41位可以表示$2^{41}-1$个毫秒的值，转化成单位年则是$(2^{41}-1) / (1000 * 60 * 60 * 24 * 365) = 69$年

第三段占10位

用来记录工作机器id。

可以部署在$2^{10} = 1024$个节点，包括5位datacenterId和5位workerId
5位（bit）可以表示的最大正整数是$2^{5}-1 = 31$，即可以用0、1、2、3、....31这32个数字，来表示不同的datecenterId或workerId

第四段占12位

序列号，用来记录同毫秒内产生的不同id。

12位（bit）可以表示的最大正整数是$2^{12}-1 = 4095$，即可以用0、1、2、3、....4094这4095个数字，来表示同一机器同一时间截（毫秒)内产生的4095个ID序号。

下图为SnowFlake算法生成解析

由于在Java中64bit的整数是long类型，所以在Java中SnowFlake算法生成的id就是long来存储的，下面附上java版源码。

1.  
2.  

3. /**

4. * SnowFlake

5. */

6. public class SnowflakeIdWorker {

7.  

8. /**

9. * 开始时间截 (1971-01-01 08:00:00)

10. * 时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数

11. * */

12. private final long twepoch = 31536000L;

13.  

14. /** 机器id所占的位数 */

15. private final long workerIdBits = 5L;

16.  

17. /** 数据标识id所占的位数 */

18. private final long datacenterIdBits = 5L;

19.  

20. /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */

21. private final long maxWorkerId = -1L ^ (-1L << workerIdBits);

22.  

23. /** 支持的最大数据标识id，结果是31 */

24. private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

25.  

26. /** 序列在id中占的位数 */

27. private final long sequenceBits = 12L;

28.  

29. /** 机器ID向左移12位 */

30. private final long workerIdShift = sequenceBits;

31.  

32. /** 数据标识id向左移17位(12+5) */

33. private final long datacenterIdShift = sequenceBits + workerIdBits;

34.  

35. /** 时间截向左移22位(5+5+12) */

36. private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

37.  

38. /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */

39. private final long sequenceMask = -1L ^ (-1L << sequenceBits);

40.  

41. /** 工作机器ID(0~31) */

42. private long workerId;

43.  

44. /** 数据中心ID(0~31) */

45. private long datacenterId;

46.  

47. /** 毫秒内序列(0~4095) */

48. private long sequence = 0L;

49.  

50. /** 上次生成ID的时间截 */

51. private long lastTimestamp = -1L;

52.  

53. /**

54. * 构造函数

55. * @param workerId 工作ID (0~31)

56. * @param datacenterId 数据中心ID (0~31)

57. */

58. public SnowflakeIdWorker(long workerId, long datacenterId) {

59. if (workerId > maxWorkerId || workerId < 0) {

60. throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));

61. }

62. if (datacenterId > maxDatacenterId || datacenterId < 0) {

63. throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));

64. }

65. this.workerId = workerId;

66. this.datacenterId = datacenterId;

67. }

68.  

69. /**

70. * 获得下一个ID (该方法是线程安全的)

71. * @return SnowflakeId

72. */

73. public synchronized long nextId() {

74. long timestamp = timeGen();

75.  

76. //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常

77. if (timestamp < lastTimestamp) {

78. throw new RuntimeException(

79. String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));

80. }

81.  

82. //如果是同一时间生成的，则进行毫秒内序列

83. if (lastTimestamp == timestamp) {

84. sequence = (sequence + 1) & sequenceMask;

85. //毫秒内序列溢出

86. if (sequence == 0) {

87. //阻塞到下一个毫秒,获得新的时间戳

88. timestamp = tilNextMillis(lastTimestamp);

89. }

90. }

91. //时间戳改变，毫秒内序列重置

92. else {

93. sequence = 0L;

94. }

95.  

96. //上次生成ID的时间截

97. lastTimestamp = timestamp;

98.  

99. //移位并通过或运算拼到一起组成64位的ID

100. return ((timestamp - twepoch) << timestampLeftShift) //

101. | (datacenterId << datacenterIdShift) //

102. | (workerId << workerIdShift) //

103. | sequence;

104. }

105.  

106. /**

107. * 阻塞到下一个毫秒，直到获得新的时间戳

108. * @param lastTimestamp 上次生成ID的时间截

109. * @return 当前时间戳

110. */

111. protected long tilNextMillis(long lastTimestamp) {

112. long timestamp = timeGen();

113. while (timestamp <= lastTimestamp) {

114. timestamp = timeGen();

115. }

116. return timestamp;

117. }

118.  

119. /**

120. * 返回以毫秒为单位的当前时间

121. * @return 当前时间(毫秒)

122. */

123. protected long timeGen() {

124. return System.currentTimeMillis();

125. }

126.  

127. /** 测试 */

128. public static void main(String[] args) {

129. SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0 , 0);

130. long start = System.currentTimeMillis();

131. for (int i = 0; i < 1000000; i++) {

132. long id = idWorker.nextId();

133. System.out.println(id);

134. }

135. long end = System.currentTimeMillis();

136. System.out.println("生成1000000id用时：" + (end-start) + "ms" );

137.  

138. }

139.  

140. }

141.  

 

小落i5低压U生成1000000个id用时8122ms 可见其速度之快。