snowflake做主键自增_自增ID算法snowflake

使用UUID或者GUID产生的ID没有规则

Snowflake算法是Twitter的工程师为实现递增而不重复的ID实现的

概述

分布式系统中&＃xff0c;有一些需要使用全局唯一ID的场景&＃xff0c;这种时候为了防止ID冲突可以使用36位的UUID&＃xff0c;但是UUID有一些缺点&＃xff0c;首先他相对比较长&＃xff0c;另外UUID一般是无序的。有些时候我们希望能使用一种简单一些的ID&＃xff0c;并且希望ID能够按照时间有序生成。而twitter的snowflake解决了这种需求&＃xff0c;最初Twitter把存储系统从MySQL迁移到Cassandra&＃xff0c;因为Cassandra没有顺序ID生成机制&＃xff0c;所以开发了这样一套全局唯一ID生成服务。

该项目地址为&＃xff1a;https://github.com/twitter/snowflake是用Scala实现的。

python版详见开源项目https://github.com/erans/pysnowflake。

结构

snowflake的结构如下(每部分用-分开):

0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000

第一位为未使用&＃xff0c;接下来的41位为毫秒级时间(41位的长度可以使用69年)&＃xff0c;然后是5位datacenterId和5位workerId(10位的长度最多支持部署1024个节点) &＃xff0c;最后12位是毫秒内的计数(12位的计数顺序号支持每个节点每毫秒产生4096个ID序号)

一共加起来刚好64位&＃xff0c;为一个Long型。(转换成字符串长度为18)

snowflake生成的ID整体上按照时间自增排序&＃xff0c;并且整个分布式系统内不会产生ID碰撞(由datacenter和workerId作区分)&＃xff0c;并且效率较高。据说&＃xff1a;snowflake每秒能够产生26万个ID。

从图上看除了第一位不可用之外其它三组均可浮动站位&＃xff0c;据说前41位就可以支撑到2082年&＃xff0c;10位的可支持1023台机器&＃xff0c;最后12位序列号可以在1毫秒内产生4095个自增的ID。

在多线程中使用要加锁。

看懂代码前 先来点计算机常识&＃xff1a;<

^异或 &＃xff1a;true^true&＃61;false   false^false&＃61;false  true^false&＃61;true false^true&＃61;true  例子&＃xff1a;  1001^0001&＃61;1000

负数的二进制&＃xff1a;

第一步:绝对值化为你需要多少位表示的二进制

第二步:各位取反,0变1,1变0

第三步:最后面加1

例子&＃xff1a;-1的二进制→      0001  取反→1110→最后面加1→1111

好了废话不多说 直接代码&＃xff1a;

1 public classIdWorker2 {3 //机器ID

4 private static longworkerId;5 private static long twepoch &＃61; 687888001020L; //唯一时间&＃xff0c;这是一个避免重复的随机量&＃xff0c;自行设定不要大于当前时间戳

6 private static long sequence &＃61; 0L;7 private static int workerIdBits &＃61; 4; //机器码字节数。4个字节用来保存机器码(定义为Long类型会出现&＃xff0c;最大偏移64位&＃xff0c;所以左移64位没有意义)

8 public static long maxWorkerId &＃61; -1L ^ -1L <

9 private static int sequenceBits &＃61; 10; //计数器字节数&＃xff0c;10个字节用来保存计数码

10 private static int workerIdShift &＃61; sequenceBits; //机器码数据左移位数&＃xff0c;就是后面计数器占用的位数

11 private static int timestampLeftShift &＃61; sequenceBits &＃43; workerIdBits; //时间戳左移动位数就是机器码和计数器总字节数

12 public static long sequenceMask &＃61; -1L ^ -1L <

13 private long lastTimestamp &＃61; -1L;14

15 ///

16 ///机器码17 ///

18 ///

19 public IdWorker(longworkerId)20 {21 if (workerId > maxWorkerId || workerId <0)22 throw new Exception(string.Format("worker Id can&＃39;t be greater than {0} or less than 0", workerId));23 IdWorker.workerId &＃61;workerId;24 }25

26 public longnextId()27 {28 lock (this)29 {30 long timestamp &＃61;timeGen();31 if (this.lastTimestamp &＃61;&＃61;timestamp)32 { //同一微秒中生成ID

33 IdWorker.sequence &＃61; (IdWorker.sequence &＃43; 1) & IdWorker.sequenceMask; //用&运算计算该微秒内产生的计数是否已经到达上限

34 if (IdWorker.sequence &＃61;&＃61; 0)35 {36 //一微秒内产生的ID计数已达上限&＃xff0c;等待下一微秒

37 timestamp &＃61; tillNextMillis(this.lastTimestamp);38 }39 }40 else

41 { //不同微秒生成ID

42 IdWorker.sequence &＃61; 0; //计数清0

43 }44 if (timestamp

46 throw new Exception(string.Format("Clock moved backwards. Refusing to generate id for {0} milliseconds",47 this.lastTimestamp -timestamp));48 }49 this.lastTimestamp &＃61; timestamp; //把当前时间戳保存为最后生成ID的时间戳

50 long nextId &＃61; (timestamp - twepoch <

55 ///

56 ///获取下一微秒时间戳57 ///

58 ///

59 ///

60 private long tillNextMillis(longlastTimestamp)61 {62 long timestamp &＃61;timeGen();63 while (timestamp <&＃61;lastTimestamp)64 {65 timestamp &＃61;timeGen();66 }67 returntimestamp;68 }69

70 ///

71 ///生成当前时间戳72 ///

73 ///

74 private longtimeGen()75 {76 return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;77 }78

79 }

调用&＃xff1a;

1 　IdWorker idworker &＃61; new IdWorker(1);2 for (int i &＃61; 0; i <1000; i&＃43;&＃43;)3 {4 Console.WriteLine(idworker.nextId());5 }

其他算法&＃xff1a;

方法一&＃xff1a;UUID

UUID是通用唯一识别码 (Universally Unique Identifier)&＃xff0c;在其他语言中也叫GUID&＃xff0c;可以生成一个长度32位的全局唯一识别码。

String uuid &＃61; UUID.randomUUID().toString()

结果示例&＃xff1a;

046b6c7f-0b8a-43b9-b35d-6489e6daee91

为什么无序的UUID会导致入库性能变差呢&＃xff1f;

这就涉及到 B&＃43;树索引的分裂&＃xff1a;

众所周知&＃xff0c;关系型数据库的索引大都是B&＃43;树的结构&＃xff0c;拿ID字段来举例&＃xff0c;索引树的每一个节点都存储着若干个ID。

如果我们的ID按递增的顺序来插入&＃xff0c;比如陆续插入8&＃xff0c;9&＃xff0c;10&＃xff0c;新的ID都只会插入到最后一个节点当中。当最后一个节点满了&＃xff0c;会裂变出新的节点。这样的插入是性能比较高的插入&＃xff0c;因为这样节点的分裂次数最少&＃xff0c;而且充分利用了每一个节点的空间。

但是&＃xff0c;如果我们的插入完全无序&＃xff0c;不但会导致一些中间节点产生分裂&＃xff0c;也会白白创造出很多不饱和的节点&＃xff0c;这样大大降低了数据库插入的性能。

方法二&＃xff1a;数据库自增主键

假设名为table的表有如下结构&＃xff1a;

id        feild

35        a

每一次生成ID的时候&＃xff0c;访问数据库&＃xff0c;执行下面的语句&＃xff1a;

begin;

REPLACE INTO table ( feild )  VALUES ( &＃39;a&＃39; );

SELECT LAST_INSERT_ID();

commit;

REPLACE INTO 的含义是插入一条记录&＃xff0c;如果表中唯一索引的值遇到冲突&＃xff0c;则替换老数据。

这样一来&＃xff0c;每次都可以得到一个递增的ID。

为了提高性能&＃xff0c;在分布式系统中可以用DB proxy请求不同的分库&＃xff0c;每个分库设置不同的初始值&＃xff0c;步长和分库数量相等&＃xff1a;

这样一来&＃xff0c;DB1生成的ID是1,4,7,10,13....&＃xff0c;DB2生成的ID是2,5,8,11,14.....