欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

自增ID算法snowflake

程序员文章站 2022-07-06 12:26:00
使用UUID或者GUID产生的ID没有规则 Snowflake算法是Twitter的工程师为实现递增而不重复的ID实现的 概述 分布式系统中,有一些需要使用全局唯一ID的场景,这种时候为了防止ID冲突可以使用36位的UUID,但是UUID有一些缺点,首先他相对比较长,另外UUID一般是无序的。有些时 ......

使用uuid或者guid产生的id没有规则

snowflake算法是twitter的工程师为实现递增而不重复的id实现的

自增ID算法snowflake

概述 
分布式系统中,有一些需要使用全局唯一id的场景,这种时候为了防止id冲突可以使用36位的uuid,但是uuid有一些缺点,首先他相对比较长,另外uuid一般是无序的。有些时候我们希望能使用一种简单一些的id,并且希望id能够按照时间有序生成。而twitter的snowflake解决了这种需求,最初twitter把存储系统从mysql迁移到cassandra,因为cassandra没有顺序id生成机制,所以开发了这样一套全局唯一id生成服务。 
该项目地址为:是用scala实现的。 
python版详见开源项目。

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

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

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

一共加起来刚好64位,为一个long型。(转换成字符串长度为18)

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

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

在多线程中使用要加锁。

 

看懂代码前 先来点计算机常识:<<左移  假如1<<2  :1左移2位=1*2^2=4(这里^是多少次方的意思,和下面的不同,哈别混淆。)

                                                     ^异或 :true^true=false   false^false=false  true^false=true false^true=true  例子:  1001^0001=1000

  负数的二进制:

第一步:绝对值化为你需要多少位表示的二进制
第二步:各位取反,0变1,1变0
第三步:最后面加1 
例子:-1的二进制→      0001  取反→1110→最后面加1→1111

好了废话不多说 直接代码:

 1 public class idworker
 2     {
 3         //机器id
 4         private static long workerid;
 5         private static long twepoch = 687888001020l; //唯一时间,这是一个避免重复的随机量,自行设定不要大于当前时间戳
 6         private static long sequence = 0l;
 7         private static int workeridbits = 4; //机器码字节数。4个字节用来保存机器码(定义为long类型会出现,最大偏移64位,所以左移64位没有意义)
 8         public static long maxworkerid = -1l ^ -1l << workeridbits; //最大机器id
 9         private static int sequencebits = 10; //计数器字节数,10个字节用来保存计数码
10         private static int workeridshift = sequencebits; //机器码数据左移位数,就是后面计数器占用的位数
11         private static int timestampleftshift = sequencebits + workeridbits; //时间戳左移动位数就是机器码和计数器总字节数
12         public static long sequencemask = -1l ^ -1l << sequencebits; //一微秒内可以产生计数,如果达到该值则等到下一微秒在进行生成
13         private long lasttimestamp = -1l;
14 
15         /// <summary>
16         /// 机器码
17         /// </summary>
18         /// <param name="workerid"></param>
19         public idworker(long workerid)
20         {
21             if (workerid > maxworkerid || workerid < 0)
22                 throw new exception(string.format("worker id can't be greater than {0} or less than 0 ", workerid));
23             idworker.workerid = workerid;
24         }
25 
26         public long nextid()
27         {
28             lock (this)
29             {
30                 long timestamp = timegen();
31                 if (this.lasttimestamp == timestamp)
32                 { //同一微秒中生成id
33                     idworker.sequence = (idworker.sequence + 1) & idworker.sequencemask; //用&运算计算该微秒内产生的计数是否已经到达上限
34                     if (idworker.sequence == 0)
35                     {
36                         //一微秒内产生的id计数已达上限,等待下一微秒
37                         timestamp = tillnextmillis(this.lasttimestamp);
38                     }
39                 }
40                 else
41                 { //不同微秒生成id
42                     idworker.sequence = 0; //计数清0
43                 }
44                 if (timestamp < lasttimestamp)
45                 { //如果当前时间戳比上一次生成id时时间戳还小,抛出异常,因为不能保证现在生成的id之前没有生成过
46                     throw new exception(string.format("clock moved backwards.  refusing to generate id for {0} milliseconds",
47                         this.lasttimestamp - timestamp));
48                 }
49                 this.lasttimestamp = timestamp; //把当前时间戳保存为最后生成id的时间戳
50                 long nextid = (timestamp - twepoch << timestampleftshift) | idworker.workerid << idworker.workeridshift | idworker.sequence;
51                 return nextid;
52             }
53         }
54 
55         /// <summary>
56         /// 获取下一微秒时间戳
57         /// </summary>
58         /// <param name="lasttimestamp"></param>
59         /// <returns></returns>
60         private long tillnextmillis(long lasttimestamp)
61         {
62             long timestamp = timegen();
63             while (timestamp <= lasttimestamp)
64             {
65                 timestamp = timegen();
66             }
67             return timestamp;
68         }
69 
70         /// <summary>
71         /// 生成当前时间戳
72         /// </summary>
73         /// <returns></returns>
74         private long timegen()
75         {
76             return (long)(datetime.utcnow - new datetime(1970, 1, 1, 0, 0, 0, datetimekind.utc)).totalmilliseconds;
77         }
78 
79     }

调用:
1  idworker idworker = new idworker(1);
2             for (int i = 0; i < 1000; i++)
3             {
4                 console.writeline(idworker.nextid());
5             }

其他算法:

方法一:uuid

uuid是通用唯一识别码 (universally unique identifier),在其他语言中也叫guid,可以生成一个长度32位的全局唯一识别码。

 

string uuid = uuid.randomuuid().tostring()

 

结果示例:

 

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

 

 

为什么无序的uuid会导致入库性能变差呢?

 

这就涉及到 b+树索引的分裂

 

 自增ID算法snowflake

 

 

众所周知,关系型数据库的索引大都是b+树的结构,拿id字段来举例,索引树的每一个节点都存储着若干个id。

 

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

 

 

 自增ID算法snowflake

 

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

 

 

方法二:数据库自增主键

 

假设名为table的表有如下结构:

 

id        feild

35        a

 

每一次生成id的时候,访问数据库,执行下面的语句:

 

begin;

replace into table ( feild )  values ( 'a' );

select last_insert_id();

commit;


replace into 的含义是插入一条记录,如果表中唯一索引的值遇到冲突,则替换老数据。

 

这样一来,每次都可以得到一个递增的id。

 

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

 

 

 

 自增ID算法snowflake

 

 

 

这样一来,db1生成的id是1,4,7,10,13....,db2生成的id是2,5,8,11,14.....