从一次 Snowflake 异常说起

基于snowflake算法实现发号器 一、背景: 清分系统需要一套id生成器服务,保证分布式情况下全局唯一。 二、算法描述: 1、原始算法: (1)snowflake是twitter开源的分布式ID生成算法,其核心思想是:一个long型的ID,使用其中43bit作为毫秒数,3bit作为机房编号,5bit作为机器编码,12bit作为毫秒内序列号。这个算法单机每毫秒内理论上最多可以生成2^12,也就是4096个ID 阅读详情

本文主要基于真实踩坑经历展开

  • 1. 异常概述

  • 2. 原因分析

    • 2.1 Snowflake工作原理

    • 2.2 问题定位

    • 2.3 排除时钟回拨

    • 2.4 研究workerid

    • 2.5 疑点

  • 3. 解决方案

    • 3.1 HostNameKeyGenerator

    • 3.2 IPSectionKeyGenerator

    • 3.3 使用我们团队自研的全局唯一ID服务

    • 3.4 其他思路

  • 4. 感谢

  • 666. 彩蛋


友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【芋艿】搞基嗨皮。

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【芋艿】】搞基嗨皮。

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【芋艿】】搞基嗨皮。 


1. 异常概述

2018年1月26日下午,业务方信贷小组的同学反馈服务执行数据库插入操作出现异常,异常信息显示数据库主键出现重复:

在仔细分析了用户的重复主键ID、机器列表、雪花算法之后,下掉55这台机器,至此,异常得以解除。

本次异常看似平常,然而仔细分析起来可能造成的后果比较严重。
(1)波及面广、影响时间长。目前大量业务都采用了雪花算法的主键生成策略,如果业务、运维同学不了解雪花算法,会造成大量的时间分析排查此问题,造成一定的业务损失。
(2)存在潜在的隐患。雪花算法除了会产生此类Workid问题,也强依赖机器时钟,如果机器上时钟回拨,会导致发号重复或者服务会处于不可用状态。

2. 原因分析

为什么会造成数据库主键重复呢?
要回答这个问题要先介绍一下作为主键生成策略主要算法之一的雪花算法的工作原理。

2.1 Snowflake工作原理

对于分布式的ID生成,以Twitter Snowflake为代表的, Flake 系列算法,属于划分命名空间并行生成的一种算法,生成的数据为64bit的long型数据,在数据库中应该用大于等于64bit的数字类型的字段来保存该值,比如在MySQL中应该使用BIGINT。

Twitter在2010年6月1日(在Flickr那篇文章发布不到4个月之后),Ryan King 在Twitter的Blog 撰文 写道:

  • Ticket Servers方案缺乏顺序的保证

  • 考虑过采用UUID,不过128-bit太长了

  • E也考虑过采用ZooKeeper所提供的 Unique Naming Seuence Nodes 所提供的 Unique Naming 特性,但是性能不能满足。(Sequence Nodes的设计目标是解决分布式锁的问题,但不解决性能要求极高的ID生成问题,直接应用是一种Hack行为)

在这种情况下,Twitter给出了 64-bit 长的 Snowflake ,它的结构是:

  • E1-bit reserved

  • E41-bit timestamp

  • E10-bit machine id

  • E12-bit sequence

在过了不到4年,2014年的5月31日,Twitter 更新了 Snowflake 的 README,其中陈述了两个容易被忽视的事实:

"We have retired the initial release of Snowflake …"

"… heavily relies on existing infrastructure at Twitter to run. "

可以看出,这个方案所支持的最小划分粒度是「毫秒 * 线程」,单线程(Snowflake 里对应的概念是 Worker)的每秒容量是12-bit,也就是接近4096。

Snowflake的意义,不仅仅在于提供了解决方式,更多的是一种基于Long长度实现具有时间相关性的id自增序列。因此,很多公司基于它进行二次改造适应自己的场景。Snowflake家族的算法还有Instagram SnowFlake、Simpleflake、Boundary flake等等。

目前业界使用当当亮哥的sharding-jdbc,一般都会采取其内置的Snowflake算法,关于二次改造我这里列举一个58沈剑在《架构师之路》系列中提出的例子。

2.2 问题定位

收到业务方反馈以后,条件反射得第一时间连问了业务方同学三个问题:

  • 你们的服务有没有什么特殊型的地方?

  • 是重启的时候发生的么?

  • 你能不能查一下对应重复的记录所在的机器,重复是不是只发生在这个ip段?

业务方也是第一时间给了反馈

  • 就是普通的微服务,普通的机器

  • 不是重启时发生的

  • 果然就是两台机器上出现了问题!

好了,那我就定位到了是workid出现了问题,马上建议业务方下掉其中一台。为什么是workid,而不是时钟回拨等其他原因,且听我慢慢道来。

2.3 排除时钟回拨

大家应该都知道雪花算法存在的缺点是:

  • 依赖机器时钟,如果机器时钟回拨,会导致重复ID生成

  • 在单机上是递增的,但是由于设计到分布式环境,每台机器上的时钟不可能完全同步,有时候会出现不是全局递增的情况(此缺点可以认为无所谓,一般分布式ID只要求趋势递增,并不会严格要求递增~90%的需求都只要求趋势递增)

我们采用的是当当的sharding-jdbc 1.4.2这个版本(1.5之前的sj并不成熟,强烈推荐使用2.x),可以说直接使用了其com.dangdang.ddframe.rdb.sharding.id.generator.self.IPIdGenerator进行主键生成,其序列号生成采用的是com.dangdang.ddframe.rdb.sharding.id.generator.self.CommonSelfIdGenerator,这里特别推荐读者读一下这两个类前面的注释,写得非常清楚。

/**
* 根据机器IP获取工作进程Id,如果线上机器的IP二进制表示的最后10位不重复,建议使用此种方式
* ,列如机器的IP为192.168.1.108,二进制表示:11000000 10101000 00000001 01101100
* ,截取最后10位 01 01101100,转为十进制364,设置workerId为364.
*
* @author DonneyYoung
*/
public class IPIdGenerator implements IdGenerator {

上面这段注释非常有用,先贴在这里,后面会详细谈到。
序列号生成采用的IPIdGenerator,当当的实现算法如下所示:

/**
* 自生成Id生成器.
*
* <p>
* 长度为64bit,从高位到低位依次为
* </p>
*
* <pre>
* 1bit   符号位
* 41bits 时间偏移量从2016年11月1日零点到现在的毫秒数
* 10bits 工作进程Id
* 12bits 同一个毫秒内的自增量
* </pre>
*
* <p>
* 工作进程Id获取优先级: 系统变量{@code sjdbc.self.id.generator.worker.id} 大于 环境变量{@code SJDBC_SELF_ID_GENERATOR_WORKER_ID}
* ,另外可以调用@{@code CommonSelfIdGenerator.setWorkerId}进行设置
* </p>
*
* @author gaohongtao
*/
@Getter
@Slf4j
public class CommonSelfIdGenerator implements IdGenerator {
   public static final long SJDBC_EPOCH;//时间偏移量,从2016年11月1日零点开始
   private static final long SEQUENCE_BITS = 12L;//自增量占用比特
   private static final long WORKER_ID_BITS = 10L;//工作进程ID比特
   private static final long SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1;//自增量掩码(最大值)
   private static final long WORKER_ID_LEFT_SHIFT_BITS = SEQUENCE_BITS;//工作进程ID左移比特数(位数)
   private static final long TIMESTAMP_LEFT_SHIFT_BITS = WORKER_ID_LEFT_SHIFT_BITS + WORKER_ID_BITS;//时间戳左移比特数(位数)
   private static final long WORKER_ID_MAX_VALUE = 1L << WORKER_ID_BITS;//工作进程ID最大值
   @Setter
   private static AbstractClock clock = AbstractClock.systemClock();
   @Getter
   private static long workerId;//工作进程ID
   static {
       Calendar calendar = Calendar.getInstance();
       calendar.set(2016, Calendar.NOVEMBER, 1);
       calendar.set(Calendar.HOUR_OF_DAY, 0);
       calendar.set(Calendar.MINUTE, 0);
       calendar.set(Calendar.SECOND, 0);
       calendar.set(Calendar.MILLISECOND, 0);
       SJDBC_EPOCH = calendar.getTimeInMillis();
       initWorkerId();
   }
   private long sequence;//最后自增量
   private long lastTime;//最后生成编号时间戳,单位:毫秒
   static void initWorkerId() {
       String workerId = System.getProperty("sjdbc.self.id.generator.worker.id");
       if (!Strings.isNullOrEmpty(workerId)) {
           setWorkerId(Long.valueOf(workerId));
           return;
       }
       workerId = System.getenv("SJDBC_SELF_ID_GENERATOR_WORKER_ID");
       if (Strings.isNullOrEmpty(workerId)) {
           return;
       }
       setWorkerId(Long.valueOf(workerId));
   }
   /**
    * 设置工作进程Id.
    *
    * @param workerId 工作进程Id
    */
   public static void setWorkerId(final Long workerId) {
       Preconditions.checkArgument(workerId >= 0L && workerId < WORKER_ID_MAX_VALUE);
       CommonSelfIdGenerator.workerId = workerId;
   }
   /**
    * 生成Id.
    *
    * @return 返回@{@link Long}类型的Id
    */
   @Override
   public synchronized Number generateId() {
   //保证当前时间大于最后时间。时间回退会导致产生重复id
       long time = clock.millis();
       Preconditions.checkState(lastTime <= time, "Clock is moving backwards, last time is %d milliseconds, current time is %d milliseconds", lastTime, time);
       // 获取序列号
       if (lastTime == time) {
           if (0L == (sequence = ++sequence & SEQUENCE_MASK)) {
               time = waitUntilNextTime(time);
           }
       } else {
           sequence = 0;
       }
       // 设置最后时间戳
       lastTime = time;
       if (log.isDebugEnabled()) {
           log.debug("{}-{}-{}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date(lastTime)), workerId, sequence);
       }
       // 生成编号
       return ((time - SJDBC_EPOCH) << TIMESTAMP_LEFT_SHIFT_BITS) | (workerId << WORKER_ID_LEFT_SHIFT_BITS) | sequence;
   }
   //不停获得时间,直到大于最后时间
   private long waitUntilNextTime(final long lastTime) {
       long time = clock.millis();
       while (time <= lastTime) {
           time = clock.millis();
       }
       return time;
   }
}

通过这段代码可以看到当当的时钟回拨在单机上是做了处理的了,不但会抛出Clock is moving backwards balabalabala的IllegalStateException,而且也做了waitUntilNextTime一直等待的处理。如果单机是时钟回拨,除非应用重启或者回拨了时间,然而,线上服务器运行得好好的,根本没人动过,所以就不是单机时钟回拨的问题。
再考虑是否是集群回拨的情况,同样,如果workerid不同出现重复主键的概率基本不可能,并且我也仔细比对了出问题两台机器的时间基本保持一致,所以虽然我们公司的机器是渐进式时间管理(据说有些公司运维直接做了一个同步脚本,如果时钟不是脚本同步,而是渐进同步的就可能会产生重复ID),也不应该是大量出现此类问题的原因(用户反馈给了我几十个重复主键ID)。
当然,这段代码还能收获的一个信息就是,debug模式你可以看到你的workerId、sequence等等信息,可是,线上运行,哪个系统会一一给你把主键ID打出来呢?线上鸡肋,鸡肋鸡肋,食之无味,弃之有味。至于怎么拿workId,请看下节。

2.4 研究WorkId

如下图所示,这就是我们全篇讨论的雪花算法:

  • 第一比特保留

  • 时间戳,41比特,从2016年11月1日零点到现在的毫秒数,可以用到2156年,100多年后才会用完

  • 机器id,10比特,这个机器id每个业务要唯一,机器id获取的策略后面会详述

  • 序列号,12比特,每台机器每毫秒最多产生4096个id,超过这个数的话会等到下一毫秒

我们细化2.3节中雪花算法的实现:

 public synchronized Number generateId() {
       long time = clock.millis();
       Preconditions.checkState(lastTime <= time, "Clock is moving backwards, last time is %d milliseconds, current time is %d milliseconds", lastTime, time);
       if (lastTime == time) {
           if (0L == (sequence = ++sequence & SEQUENCE_MASK)) {
               time = waitUntilNextTime(time);
           }
       } else {
           sequence = 0;
       }
       lastTime = time;
       if (log.isDebugEnabled()) {
           log.debug("{}-{}-{}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date(lastTime)), workerId, sequence);
       }
       return ((time - SJDBC_EPOCH) << TIMESTAMP_LEFT_SHIFT_BITS) | (workerId << WORKER_ID_LEFT_SHIFT_BITS) | sequence;
   }
  • TIMESTAMP_LEFT_SHIFT_BITS时间戳左移22位

  • WORKER_ID_LEFT_SHIFT_BITS工作机器ID左移动12位

  • 最后12位序列号

进一步研究一下workid基于IPIdGenerator的实现

CommonSelfIdGenerator.setWorkerId((long) (((ipAddressByteArray[ipAddressByteArray.length - 2] & 0B11) << Byte.SIZE) + (ipAddressByteArray[ipAddressByteArray.length - 1] & 0xFF)));

可以很清楚得看到,这就是取ip的最后两个段,一共取10bit,和我之前强调的注释说得一模一样

根据机器IP获取工作进程Id,如果线上机器的IP二进制表示的最后10位不重复,建议使用此种方式,列如机器的IP为192.168.1.108,二进制表示:11000000 10101000 00000001 01101100,截取最后10位 01 01101100,转为十进制364,设置workerId为364.

然后把我们出问题的机器XXX.XXX.209.55,XXX.XXX.161.55(出于安全数据脱敏)转化为workid,发现都是一样的。
当然,你也可以使用下面代码自己跑出workid。

@Test
   public void generateId3() throws UnknownHostException, NoSuchFieldException, IllegalAccessException {
       String ipv4s =
//                "XXX.XXX.161.55\n"
               "XXX.XXX.209.55\n"
//                "XXX.XXX.209.126 \n" +
//                "XXX.XXX.209.127\t\n" +
//                "XXX.XXX.208.227 \n" +
//                "XXX.XXX.148.134 \n" +
//                "XXX.XXX.148.135\t\n" +
//                "XXX.XXX.148.132\t\n" +
//                        "XXX.XXX.148.133";
       ;
       for (String ipv4 : ipv4s.split("\n")) {
           ipv4 = ipv4.replaceAll("\t", "").trim();
           byte[] ipv4Byte = new byte[4];
           String[] ipv4StingArray = ipv4.split("\\.");
           for (int i = 0; i < 4; i++) {
               ipv4Byte[i] = (byte) Integer.valueOf(ipv4StingArray[i]).intValue();
           }
           address = InetAddress.getByAddress("dangdang-db-sharding-dev-233", ipv4Byte);
           PowerMockito.mockStatic(InetAddress.class);
           PowerMockito.when(InetAddress.getLocalHost()).thenReturn(address);
           IPKeyGenerator.initWorkerId();
//            IPSectionKeyGenerator.initWorkerId();
           Field workerIdField = DefaultKeyGenerator.class.getDeclaredField("workerId");
           workerIdField.setAccessible(true);
           System.out.println(ipv4 + "\t" + workerIdField.getLong(DefaultKeyGenerator.class));
       }
   }

另外我们也可以根据用户提供的所有重复的ID反解workerid

psvm+sout+(ID/4096%1024)

/4096的意思是整除2的12次方,变相干掉12bit序列号,%1024的意思是取2的十次方的余数,拿到工作机器id
居然所有用户的重复ID反解出来的workerid都是一样的。至此,我们可以得到结论,workerid重复导致了线上主键重复

2.5 疑点

但是上面的推测还有一个谜团没有解开,就是只有Workerid相同,41bit的时间戳和12bit的序列号怎么可能碰撞那么严重,两天内出现了近百次冲突?如果说这个碰撞和hashmap的碰撞一样,那么也一定是高并发低概率的,为什么会这么频繁?
所以,我又追问了业务方一个问题:

  • 你们的并发度如何?

业务方给我的反馈是“并发量不大”。

我顿时明白了,翻了一下上面序列号生成的代码实现,该序列是用来在同一个毫秒内生成不同的Id,该Id顺序递增,如果在这个毫秒内生成的数量超过4096(2的12次方),那么生成器会等待到下个毫秒继续生成。从Id的组成部分看,不同进程的Id肯定是不同的,同一个进程首先是通过时间位保证不重复,如果时间相同则是通过序列位保证。 同时由于时间位是单调递增的,且各个服务器如果大体做了时间同步,那么生成的Id在分布式环境可以认为是总体有序的。

通过

psvm+sout+(ID%4096)

验证得知,所有重复主键ID的序列号都是0,完全印证了我的猜想。

所以,因为序列号是从0开始递增的,结论就是只要workerid相同,同时在这两台机器上出现请求,就会产生重复,或者说只要线上IP末尾相同,就有可能会产生重复!!!

3. 解决方案

运维下线了重复的55一台旧机器解决了此问题。了解到以前公司的机器IP都是连号的没有出现这种并行的形式,这次是新老机器并存导致的。当然还有别的解决方案。

3.1 HostNameKeyGenerator

根据机器名最后的数字编号获取工作进程编号。如果线上机器命名有统一规范,建议使用此种方式。例如,机器的 HostName 为: dangdang-db-sharding-dev-01(公司名-部门名-服务名-环境名-编号),会截取 HostName 最后的编号 01 作为工作进程编号( workId )。

3.2 IPSectionKeyGenerator

改进版本的IP生成策略。

浏览 IPKeyGenerator 工作进程编号生成的规则后,感觉对服务器IP后10位(特别是IPV6)数值比较约束。 
有以下优化思路: 
因为工作进程编号最大限制是 2^10,我们生成的工程进程编号只要满足小于 1024 即可。 
1.针对IPV4: 
….IP最大 255.255.255.255。而(255+255+255+255) < 1024。 
….因此采用IP段数值相加即可生成唯一的workerId,不受IP位限制。

  1. 针对IPV6: 
    ….IP最大 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 
    ….为了保证相加生成出的工程进程编号 < 1024,思路是将每个 Bit 位的后6位相加。这样在一定程度上也可以满足workerId不重复的问题。 
    使用这种 IP 生成工作进程编号的方法,必须保证IP段相加不能重复

对于 IPV6 :2^ 6 = 64。64 * 8 = 512 < 1024。

// IPSectionKeyGenerator.java
static void initWorkerId() {
  InetAddress address;
  try {
      address = InetAddress.getLocalHost();
  } catch (final UnknownHostException e) {
      throw new IllegalStateException("Cannot get LocalHost InetAddress, please check your network!");
  }
  byte[] ipAddressByteArray = address.getAddress();
  long workerId = 0L;
  // IPV4
  if (ipAddressByteArray.length == 4) {
      for (byte byteNum : ipAddressByteArray) {
          workerId += byteNum & 0xFF;
      }
  // IPV6
  } else if (ipAddressByteArray.length == 16) {
      for (byte byteNum : ipAddressByteArray) {
          workerId += byteNum & 0B111111;
      }
  } else {
      throw new IllegalStateException("Bad LocalHost InetAddress, please check your network!");
  }
  DefaultKeyGenerator.setWorkerId(workerId);
}

PS:此人的思路虽然巧妙,也不能绝对OK,例如,254.255和255.254会重复,172.16.x.x,即使这个段,也是2的16次方,不过也能凑活得用,还是基于etcd或者zk发号靠谱。
或者只要公司机器编号准确,HostNameKeyGenerator也是非常靠谱的。

3.3 使用我们团队自研的全局唯一ID服务

做到的地方

  • 高可用,短ID服务允许部署多套完全独立的环境,每个环境产生的ID都不一样,client可以failover到任何环境

  • 高性能,每秒钟可以获取百万级的ID,并且不会出现阻塞

  • 基于时间的大致有序,基本上获取到的ID会越来越大,无法保证严格有序,比如一小时前获取的ID应该会比一小时后的小

  • 一致性,绝对保证不会获取到重复的ID(服务端保证)

做不到的地方

  • 无法保证严格全局有序

  • 无法保证按照时间有序

  • 无法保证每个ID都不浪费

3.4 其他思路

  • 美团开源的leaf在zookeeper协调雪花算法时钟回拨,一直刷等回拨导致重复的时候过去,其实在2017年闰秒的时候就出现过这个情况,leaf还是成功避免了。

  • 还有一种避免回拨的方式是用1~2台关闭NTP时钟的机器做backup

  • 百度的snakeflow是使用了预先分配id的方式来避免这种情况,虽然不能完全避免,其实预先分配是比较合理的方式

  • 还有别的解决方案,重复的时间后面可以增加版本号,做专门的校时服务器,因为集群获取机器时间就会有时间窗口问题,造成生成的Id编号重复

  • 最好的方案还是老老实实使用数据库生成的那种(数据库号段生成的分布式ID),对业务影响不大就用snakeflow。因为InnoDB表的数据写入顺序能和B+树索引的叶子节点顺序一致的话,这时候存取效率是最高的,所以考虑主键的时候,一般需要自增、或者趋势自增。

  • 上文提到的基于host,其实也是一种不错的解决方案

4. 感谢

这是公众号「工匠小猪猪的技术世界」的第一篇文章,感谢「芋道源码」芋艿在技术、排版等方面给予的大力指导!

666. 彩蛋

第一篇 公众号 的文章,如果有地方写的不正确,还望指出,谢谢。

更多 分布式ID 内容,推荐阅读如下文章:

  • 美团 —— 《Leaf——美团点评分布式ID生成系统》

  • 58 —— 《细聊分布式ID生成方法》

  • 芋道源码 —— 《谈谈 ID》

  • 王延炯博士 —— 《生成全局唯一ID的3个思路,来自一个资深架构师的总结》

使用Snowflake加载数据的实战指南 Snowflake作为一款云数据平台,可以处理海量数据并支持复杂的SQL查询。在数据处理工作流中,我们常常需要从Snowflake中提取数据以供后续分析和处理。为了简化这一过程,可以使用库进行数据加载。 阅读详情

相关推荐

PySpark读Snowflake只读最佳实践:连接、性能与排错

PySpark连接Snowflake是现代数据平台中典型的跨系统集成场景,其本质是通过Spark Connector将Snowflake作为分布式查询后端进行联邦访问。核心原理在于Connector绕过JDBC原生限制,实现谓词下推、精准类型映射与自动分片,从而避免全表扫描和类型失真等常见问题。该技术方案显著提升ETL与特征工程效率,降低Virtual Warehouse资源浪费,并支撑高并发、低延迟的数据分析任务。典型应用场景包括数仓分层同步、机器学习特征抽取、实时报表底表构建等。本文聚焦生产级只读链路,

weixin_33834628的博客 390

C# 实现 Snowflake算法

使用UUID或者GUID产生的ID没有规则 Snowflake算法是Twitter的工程师为实现递增而不重复的ID实现的 从图上看除了第一位不可用之外其它三组均可浮动站位,据说前41位就可以支撑到2082年,10位的可支持1023台机器,最后12位序列号可以在1毫秒内产生4095个自增的ID。 在多线程中使用要加锁。 /// /// 动态生产有规律的I

飞哥的专栏 1万+

C#: 实现雪花算法

雪花算法通过将一个64位的整数划分为不同的部分,包括时间戳、数据中心ID、机器ID和序列号,从而保证了生成的ID在分布式环境下的唯一性和有序性。最后的12位是一个序列号,表示同一毫秒内生成的不同ID。然后根据雪花算法的结构,将不同的部分合并成一个64位的整数,并返回作为生成的唯一ID。雪花算法的核心思想是使用一个64位的整数作为ID,将这个整数划分为不同的部分,每个部分表示不同的含义。当同一毫秒内生成的ID超过了4095个(12位的序列号最大可以表示的数值),将会等待下一毫秒,直到下一毫秒再继续生成ID。

PixelShadeZ的博客 899

C# 实现分布式自增 ID 算法 Snowflake(雪花算法)

需求概述 分布式系统中,有一些需要使用全局唯一 ID 的场景,这种时候为了防止ID冲突可以使用36位的通用唯一识别码/UUID(Universally Unique Identifier),但是 UUID 有一些缺点,首先他相对比较长,另外 UUID 一般是无序的。有些时候我们希望能使用一种简单一些的 ID,并且希望 ID 能够按照时间有序生成。 Twitter-Snowflake 产生背景 Twitter 早期用 MySQL 存储数据,随着用户的增长,单一的 MySQL 实例没法承受海量的数据.

ChaITSimpleLove的博客 7511

C#实现Snowflake雪花算法(附完整源码)

C#实现Snowflake雪花算法(附完整源码)

希望我的博客,能帮上你解决学习中工作中所遇到的问题 641

雪花序列算法Snowflake的C#实现版本

这个类是由java改过来的,带有excel说明 ( 2022-07-23 修改) * Twitter_Snowflake<br> * SnowFlake的结构如下(每部分用-分开):<br> * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br> * 1位标识,由于long基本类型在Java中是带符号的,最高位是符号位,正数是0,负数是1,所以id一般是正数,最高位是0<br> * 41位时间截(毫秒级),注意,41位时间截不是存储当前时间的时间截,而是存储时间截的差值(当前时间截 - 开始时间截) * 得到的值),这里的的开始时间截,一般是我们的id生成器开始使用的时间,由我们程序来指定的(如下下面程序IdWorker类的startTime属性)。41位的时间截,可以使用69年,年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69

snowflake改进_从一次 Snowflake 异常说起

1. 异常概述2018年1月26日下午,业务方信贷小组的同学反馈服务执行数据库插入操作出现异常,异常信息显示数据库主键出现重复:在仔细分析了用户的重复主键ID、机器列表、雪花算法之后,下掉55这台机器,至此,异常得以解除。本次异常看似平常,然而仔细分析起来可能造成的后果比较严重。 (1)波及面广、影响时间长。目前大量业务都采用了雪花算法的主键生成策略,如果业务、运维同学不了解雪花算法,会造成大量的...

weixin_39551103的博客 428

基于Java的高校校园点餐系统

本文介绍了一个基于Java技术开发的高校校园点餐系统,该系统以B/S结构为基础,采用MySQL作为数据库,实现了一个高效、便捷的在线点餐平台。系统主要面向三类用户:管理员、用户和食堂工作人员,提供包括用户管理、食堂管理、菜单管理、订单管理等在内的多项功能。通过系统的具体测试,验证了其可行性和有效性,为高校师生提供了一个科学化、系统化的点餐服务。高校校园点餐系统的开发和实现,不仅提高了校园餐饮服务的效率和质量,也为师生提供了一个更加便捷的点餐体验。

a632341031的博客 841

从一次Snowflake异常说起

摘要: 原创出处微信公众号 「工匠小猪猪的技术世界」欢迎转载,保留摘要,谢谢! 本文主要基于真实踩坑经历展开 1. 异常概述 2. 原因分析 2.1 Snowflake工作原理 2.2 问题定位 2.3 排除时钟回拨 2.4 研究workerid 2.5 疑点 3. 解决方案 3.1 HostNameKeyGenerator 3.2 IPSectionKeyGenerator 3.3 ...

weixin_33908217的博客 296

WinIDEA基于IC5000烧录代码和调试教程

winIDEA就是ic5000用来烧录代码和调试代码的上位机,本文旨在介绍其如何去烧录代码并且调试

m0_56208280的博客 4166

基础知识学习 -- qnx 系统

qnx os车载系统

求变,从思想开始 3881

Snowflake算法

具体详解请看:http://www.lanindex.com/twitter-snowflake%EF%BC%8C64%E4%BD%8D%E8%87%AA%E5%A2%9Eid%E7%AE%97%E6%B3%95%E8%AF%A6%E8%A7%A3/   代码来源于网络: public class IdWorker { //http://www.lanindex.com/...

yhl_woniu的专栏 244

【算法】基于STM32的MPU6050卡尔曼滤波算法(入门级)

1. 简介 卡尔曼滤波(Kalman filtering)是一种利用线性系统状态方程,通过系统输入输出观测数据,对系统状态进行最优估计的算法。由于观测数据中包括系统中的噪声和干扰的影响,所以最优估计也可看作是滤波过程。详情见:卡尔曼滤波简介 MPU6050的解算主要有三种姿态融合算法:四元数法 、一阶互补算法和卡尔曼滤波算法。我们常用的DMP库使用的是四元数法,本文采用卡尔曼滤波算法,使用RT-Thread国产操作系统,利用env工具进行串口、模拟IIC环境配置,使用10ms的线程进行卡尔曼滤波解算。 2.

weixin_44549777的博客 3万+

snowflake的一些总结

前言 假如面试时候,问到分布式唯一ID生成的相关问题,我觉得snowflake应绕不开,既然绕不开,那怎么回答呢? 简洁介绍 64位的二进制表示,分了4块 第1块不用管,0是固定的,表示正数。 核心就在后3块。 第2块: 当前时间戳减 开始时间戳,单位毫秒。 开始时间一般指定位项目上线日期就行。 很多博客都简略的说“时间戳”,包括图片中也是。 很容易混淆,这里存的可不是你用xx语言的一个time相关的API调用得出的那个值。 第3块: 10位,范围 0~1023 = 1024 .

daima_caigou的博客 704

C#串口通信从入门到精通(5)——打开、关闭串口

本文详细介绍如何打开串口

qq_34059233的博客 6786

华为OD机试 - TLV格式(Python/JS/C/C++ 2025 C卷 100分)

两端通过TLV格式的报文来通信,现在收到对端的一个TLV格式的消息包,要求生成匹配后的(tag,length,valueOffset)列表。和需要匹配的n个tag对应的n行匹配结果,每一行由长度和偏移量组成。第二行:需要匹配的tag数量n(0 < n < 1000)后面N行:需要匹配n个tag值(十进制表示),递增排列。标签10(0A)存在,长度3,valueOffset=2。标签15(0F)长度4,valueOffset=2。标签14(0E)长度2,valueOffset=8。

学Java,找哪吒 2049

Ballerina Snowflake 模块常见问题解决方案

Ballerina Snowflake 模块常见问题解决方案 项目基础介绍 Ballerina Snowflake 模块是一个开源项目,旨在为 Ballerina 编程语言提供一个与 Snowflake 数据库进行交互的连接器。Snowflake 是一个基于云的数据平台,提供了一个数据仓库即服务(Data Warehouse as a Service),专门为云环境设计。该模块允许用户通过 Bal...

gitblog_00958的博客 630

《ESP32单片机基础入门》第2章:开发环境搭建

【代码】《ESP32单片机基础入门》第2章:开发环境搭建。

2301_79143213的博客 582

DLSS Swapper 教程:4 步安全升级或回退你游戏的 DLSS 版本

先锁定目标:把一款你常玩游戏里的 DLSS 版本,从旧版换到最新可用版,不用等官方补丁。DLSS Swapper 就是干这个的——一款免费开源的 Windows 工具,负责把游戏里的 DLSS、FSR、XeSS 动态库(DLL)下载、管理并替换掉。换坏了也不怕,它会自动给原始文件留底,点一下就能回滚。下面这套流程,从装好到换完一共 4 步。 ## 如何安装 DLSS Swapper:winget

gitblog_00136的博客 734

GEE生物量预测:利用多源遥感数据和随机森林算法RF构建地上生物量(AGB)预测模型,并实现未来年份的生态变化模拟(大面积生物量反演)

数据融合策略:整合5类遥感产品(AGB、NDVI、LAI、土地覆盖、地形)时序特征构建:采用生长季中值法降低云污染影响机器学习优化分层采样保证数据代表性80棵决策树平衡精度与效率预测可靠性基准期R²达0.76需结合地面实测数据校正。

此星光明博客 419

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

SnowFlake算法

分布式环境下生成全剧唯一的ID的方式: 一、UUID 生成比较简单,能保证全局唯一性;但是生成的是无序的ID序列,作为主键ID性能较差(无法使用索引) 二、数据库主键自增 可以根据数据库的自增来实现,分布式系统可以为多个数据库节点设置自增步长保证全局唯一;但是这样需要依赖数据库,不但性能较差而且数据库挂掉会导致服务不可用 id feild //数据库字段 35 a //用于获...

qq_38836082的博客 371

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

C++11 实现 Twitter Snowflake

SnowflakeIdWorker c++11 Twitter Snowflake c++11实现版本 代码位置 SnowFlake 算法生成的 id 是一个64位大小的整数, 它的结构如下图: - 1位: 不用, 二进制中最高位为1的都是负数, 但是我们生成的id一般都使用整数, 所以这个最高位固定是0. 41位: 用来记录时间戳(毫秒级), 注意, 这里存储的不是当前的时间戳,而是...

qq_24653691的博客 452

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Snowflake

public class Snowflake { private static long machineId;//机器ID private static long datacenterId = 0L;//数据ID private static long sequence = 0L;//计数从零开始 ...

weixin_30402085的博客 98
上一篇: 分布式事务 TCC-Transaction 源码分析 —— Dubbo 支持
下一篇: 注册中心 Eureka 源码解析 —— Eureka-Client 初始化(三)之 EurekaClient
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值