上一首歌诗，她们聊了哈哈隐脉户主有关的许多基本上知识，概要能参见：《承载力日活一千万普通用户的高mammalian控制技术，如果什么样结构设计其统计数据库结构结构设计？》。

这首诗，她们就接着隐脉户主的知识，来概要聊哈哈由上而下唯一id什么样裂解。

在隐脉户主后你倘若要正视的三个痛点，是id咋裂解？

即便即便三个表分成多个Caura，每一表的id都从1早已早已开始相加自稳步增长，那确实不对啊。

举个实例，你的供货表拆分以求1024张供货表，每一表的id都从1早已早已开始相加，这个确实有痛点了！

你的控制技术就没配套措施依照表操作符来翻查供货了，比如id = 50这个供货，在每一UX21LI2677E都有！

因此此时就须要分布式控制技术结构结构设计下的由上而下唯一id裂解的计划了，在隐脉户主后，对插入统计数据库中的中心思想id，无法间接地纯粹采用表自增id，要由上而下裂解唯一id，接着插入各注记，保证每一表内的某一id，由上而下惟一。

比如供货表尽管拆分以求1024Aulaye，但id = 50这个供货，只会存有于三个UX21LI2677E。

因此什么样同时实现由上而下唯一id呢？有下列四种计划。

（1）计划一：并立统计数据库自增id

这个计划是说你的控制技术每晚要裂解三个id，都是往三个并立库的三个并立UX21LI2677E插入四条没关系销售业务含意的统计数据，接着以以获取三个统计数据库自增的三个id。拿到这个id后再往密切有关的隐脉户主里去写入。

比如说你有三个auto_id库，里头就三个表，叫作auto_id表，有三个id是自稳步增长的。

因此你每晚要以以获取三个由上而下唯一id，间接地往这个UX21LI2677E插入四条历史记录，以以获取三个由上而下惟一id方可，接着这个由上而下唯一id就能插入供货的隐脉户主中。

这个计划的益处是方便快捷纯粹，谁单厢用。优点是单库裂解自增id，即便高mammalian的话，就会有困局的，即便auto_id库即便贯穿个每秒钟几十万mammalian，确实是不现实生活的了。

（2）计划二：uuid

这个每一人都如果知道吧，是用UUID裂解三个由上而下唯一的id。

益处是每一控制技术本地裂解，不要基于统计数据库来了

不好之处是，uuid太长了，作为操作符性能太差了，不适合用于操作符。

如果你是要随机裂解个什么文件名了，编号之类的，你能用uuid，但作为操作符是无法用uuid的。

（3）计划三：以以获取控制技术当前时间

这个计划的意思是以以获取当前时间作为由上而下唯一的id。

但痛点是，mammalian很高的时候，比如一秒mammalian几千，会有重复的情况，这个是确实不合适的。

一般如果用这个计划，是将当前时间跟很多其他的业务字段拼接起来，作为三个id，如果销售业务上你觉得能接受，因此也是能的。

你能将别的销售业务字段值跟当前时间拼接起来，组成三个由上而下唯一的编号，比如供货编号：时间戳 + 普通用户id + 销售业务含意编码。

（4）计划四：snowflake算法的思想分析

snowflake算法，是twitter开源的分布式系统控制技术id裂解算法。

其中心思想思想是：采用三个64 bit的long型的数字作为由上而下唯一id，这64个bit中，其中1个bit是不用的，接着用其中的41 bit作为毫秒数，用10 bit作为工作机器id，12 bit作为序列号。

给大家举个实例吧，比如下面这个64 bit的long型数字，大家看看

上面第三个部分，是1个bit：0，这个是无意义的

上面第二个部分是41个bit：表示的是时间戳

上面第三个部分是5个bit：表示的是机房id，10001

上面第四个部分是5个bit：表示的是机器id，1 1001

上面第五个部分是12个bit：表示的序号，是某一机房某台机器上这一毫秒内同时裂解的id的序号，0000 00000000

1 bit：是不用的，为啥呢？

即便二进制里第三个bit为如果是1，因此都是负数，但她们裂解的id都是正数，因此第三个bit统一都是0

41 bit：表示的是时间戳，单位是毫秒。

41 bit能表示的数字多达2^41 - 1，也是能标识2 ^ 41 - 1个毫秒值，换算成年是表示69年的时间。

10 bit：历史记录工作机器id，代表的是这个服务最多能部署在2^10台机器上，也是1024台机器。

但10 bit里5个bit代表机房id，5个bit代表机器id。意思是最多代表2 ^ 5个机房（32个机房），每一机房里能代表2 ^ 5个机器（32台机器）。

12 bit：这个是用来历史记录同三个毫秒内产生的不同id。

12 bit能代表的最大正整数是2 ^ 12 - 1 = 4096，也是说能用这个12bit代表的数字来区分同三个毫秒内的4096个不同的id

纯粹来说，你的某一服务假设要裂解三个由上而下唯一id，因此就能发送三个请求给部署了snowflake算法的控制技术，由这个snowflake算法控制技术来裂解唯一id。

这个snowflake算法控制技术首先确实是知道自己所在的机房和机器的，比如机房id = 17，机器id = 12。

接着snowflake算法控制技术接收到这个请求后，首先就会用二进制位运算的方式裂解三个64 bit的long型id，64个bit中的第三个bit是无意义的。

接着41个bit，就能用当前时间戳（单位到毫秒），接着接着5个bit设置上这个机房id，还有5个bit设置上机器id。

最后再判断哈哈，当前这台机房的这台机器上这一毫秒内，这是第几个请求，给这次裂解id的请求相加三个序号，作为最后的12个bit。

最终三个64个bit的id就出来了，类似于：

这个算法能保证说，三个机房的一台机器上，在同一毫秒内，裂解了三个唯一的id。可能三个毫秒内会裂解多个id，但有最后12个bit的序号来区分开来。

下面她们纯粹看看这个snowflake算法的两个代码同时实现，这是个示例，大家如果理解了这个意思后，以后能自己尝试改造这个算法。

总之是用三个64bit的数字中各bit位来设置不同的标志位，区分每三个id。

（5）snowflake算法的代码同时实现

publicclassIdWorker{privatelongworkerId;// 这个是代表了机器idprivatelongdatacenterId;// 这个是代表了机房idprivatelongsequence;// 这个是代表了一毫秒内裂解的多个id的最新序号publicIdWorker(longworkerId,longdatacenterId,longsequence){// sanity check for workerId// 这儿不就检查了哈哈，要求是你传递进来的机房id和机器id无法超过32，无法小于0if(workerId > maxWorkerId || workerId <0) {thrownewIllegalArgumentException( String.format("worker Id cant be greater than %d or less than 0",maxWorkerId)); }if(datacenterId > maxDatacenterId || datacenterId <0) {thrownewIllegalArgumentException( String.format("datacenter Id cant be greater than %d or less than 0",maxDatacenterId)); }this.workerId = workerId;this.datacenterId = datacenterId;this.sequence = sequence; }privatelongtwepoch =1288834974657L;privatelongworkerIdBits =5L;privatelongdatacenterIdBits =5L;// 这个是二进制运算，是5 bit最多只能有31个数字，也是说机器id最多只能是32以内privatelongmaxWorkerId =-1L^ (-1L<< workerIdBits);// 这个是三个意思，是5 bit最多只能有31个数字，机房id最多只能是32以内privatelongmaxDatacenterId =-1L^ (-1L<< datacenterIdBits);privatelongsequenceBits =12L;privatelongworkerIdShift = sequenceBits;privatelongdatacenterIdShift = sequenceBits + workerIdBits;privatelongtimestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;privatelongsequenceMask =-1L^ (-1L<< sequenceBits);privatelonglastTimestamp =-1L;publiclonggetWorkerId(){returnworkerId; }publiclonggetDatacenterId(){returndatacenterId; }publiclonggetTimestamp(){returnSystem.currentTimeMillis(); }// 这个是中心思想方法，通过调用nextId()方法，让当前这台机器上的snowflake算法程序裂解三个由上而下唯一的idpublicsynchronizedlongnextId(){// 这儿是以以获取当前时间戳，单位是毫秒longtimestamp = timeGen();if(timestamp < lastTimestamp) { System.err.printf("clock is moving backwards. Rejecting requests until %d.", lastTimestamp);thrownewRuntimeException( String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp)); }// 下面是说假设在同三个毫秒内，又发送了三个请求裂解三个id// 这个时候就得把seqence序号给递增1，最多是4096if(lastTimestamp == timestamp) {// 这个意思是说三个毫秒内最多只能有4096个数字，无论你传递多少进来，//这个位运算保证始终是在4096这个范围内，避免你自己传递个sequence超过了4096这个范围sequence = (sequence +1) & sequenceMask;if(sequence ==0) { timestamp = tilNextMillis(lastTimestamp); } }else{ sequence =0; }// 这儿历史记录哈哈最近一次裂解id的时间戳，单位是毫秒lastTimestamp = timestamp;// 这儿是最中心思想的二进制位运算操作，裂解三个64bit的id// 先将当前时间戳左移，放到41 bit那儿；将机房id左移放到5 bit那儿；将机器id左移放到5 bit那儿；将序号放最后12 bit// 最后拼接起来成三个64 bit的二进制数字，转换成10进制是个long型return((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence; }privatelongtilNextMillis(longlastTimestamp){longtimestamp = timeGen();while(timestamp <= lastTimestamp) { timestamp = timeGen(); }returntimestamp; }privatelongtimeGen(){returnSystem.currentTimeMillis(); }//---------------测试---------------publicstaticvoidmain(String[] args){ IdWorker worker =newIdWorker(1,1,1);for(inti =0; i <30; i++) { System.out.println(worker.nextId()); } } }