关键词：
关于雪花
雪花(snowflake)在自然界中，是极具独特美丽，又变幻莫测的东西：
- 雪花属于六方晶系，它具有四个结晶轴，其中三个辅轴在一个基面上，互相以60度的角度相交，第四轴(主晶轴)与三个辅轴所形成的基面垂直；
- 雪花的基本形状是六角形，但是大自然中却几乎找不出两朵完全相同的雪花，每一个雪花都拥有自己的独有图案，就象地球上找不出两个完全相同的人一样。许多学者用显微镜观测过成千上万朵雪花，这些研究最后表明，形状、大小完全一样和各部分完全对称的雪花，在自然界中是无法形成的。
雪花算法：
雪花算法的原始版本是scala版，用于生成分布式ID（纯数字，时间顺序）,订单编号等。
自增ID：对于数据敏感场景不宜使用，且不适合于分布式场景。
GUID：采用无意义字符串，数据量增大时造成访问过慢，且不宜排序。
算法描述：
- 最高位是符号位，始终为0，不可用。
- 41位的时间序列，精确到毫秒级，41位的长度可以使用69年。时间位还有一个很重要的作用是可以根据时间进行排序。
- 10位的机器标识，10位的长度最多支持部署1024个节点。
- 12位的计数序列号，序列号即一系列的自增id，可以支持同一节点同一毫秒生成多个ID序号，12位的计数序列号支持每个节点每毫秒产生4096个ID序号。
# Donet版本 ```c# using System;
namespace System
///
/// 分布式ID算法（雪花算法）
///
public class Snowflake
private static long machineId;//机器ID
private static long datacenterId = 0L;//数据ID
private static long sequence = 0L;//计数从零开始
private static long twepoch = 687888001020L; //唯一时间随机量
private static long machineIdBits = 5L; //机器码字节数
private static long datacenterIdBits = 5L;//数据字节数
public static long maxMachineId = -1L ^ -1L << (int)machineIdBits; //最大机器ID
private static long maxDatacenterId = -1L ^ (-1L << (int)datacenterIdBits);//最大数据ID
private static long sequenceBits = 12L; //计数器字节数，12个字节用来保存计数码
private static long machineIdShift = sequenceBits; //机器码数据左移位数，就是后面计数器占用的位数
private static long datacenterIdShift = sequenceBits + machineIdBits;
private static long timestampLeftShift = sequenceBits + machineIdBits + datacenterIdBits; //时间戳左移动位数就是机器码+计数器总字节数+数据字节数
public static long sequenceMask = -1L ^ -1L << (int)sequenceBits; //一微秒内可以产生计数，如果达到该值则等到下一微妙在进行生成
private static long lastTimestamp = -1L;//最后时间戳
private static object syncRoot = new object();//加锁对象
static Snowflake snowflake;
public static Snowflake Instance()
if (snowflake == null)
snowflake = new Snowflake();
return snowflake;
public Snowflake()
Snowflakes(0L, -1);
public Snowflake(long machineId)
Snowflakes(machineId, -1);
public Snowflake(long machineId, long datacenterId)
Snowflakes(machineId, datacenterId);
private void Snowflakes(long machineId, long datacenterId)
if (machineId >= 0)
if (machineId > maxMachineId)
throw new Exception("机器码ID非法");
Snowflake.machineId = machineId;
if (datacenterId >= 0)
if (datacenterId > maxDatacenterId)
throw new Exception("数据中心ID非法");
Snowflake.datacenterId = datacenterId;
/// <summary>
/// 生成当前时间戳
/// </summary>
/// <returns>毫秒</returns>
private static long GetTimestamp()
return (long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds;
/// <summary>
/// 获取下一微秒时间戳
/// </summary>
/// <param name="lastTimestamp"></param>
/// <returns></returns>
private static long GetNextTimestamp(long lastTimestamp)
long timestamp = GetTimestamp();
if (timestamp <= lastTimestamp)
timestamp = GetTimestamp();
return timestamp;
/// <summary>
/// 获取长整型的ID
/// </summary>
/// <returns></returns>
public long GetId()
lock (syncRoot)
long timestamp = GetTimestamp();
if (Snowflake.lastTimestamp == timestamp)
//同一微妙中生成ID
sequence = (sequence + 1) & sequenceMask; //用&运算计算该微秒内产生的计数是否已经到达上限
if (sequence == 0)
//一微妙内产生的ID计数已达上限，等待下一微妙
timestamp = GetNextTimestamp(lastTimestamp);
else
//不同微秒生成ID
sequence = 0L;
if (timestamp < lastTimestamp)
throw new Exception("时间戳比上一次生成ID时时间戳还小，故异常");
Snowflake.lastTimestamp = timestamp; //把当前时间戳保存为最后生成ID的时间戳
long Id = ((timestamp - twepoch) << (int)timestampLeftShift)
| (datacenterId << (int)datacenterIdShift)
| (machineId << (int)machineIdShift)
| sequence;
return Id;
<br/>
<br/>
# Golang版
_snowflake.go_
```go
package snowflake
// twitter 雪花算法
// 把时间戳,工作机器ID, 序列号组合成一个 64位 int
// 第一位置零, [2,42]这41位存放时间戳,[43,52]这10位存放机器id,[53,64]最后12位存放序列号
import "time"
var (
machineID int64 // 机器 id 占10位, 十进制范围是 [ 0, 1023 ]
sn int64 // 序列号占 12 位,十进制范围是 [ 0, 4095 ]
lastTimeStamp int64 // 上次的时间戳(毫秒级), 1秒=1000毫秒, 1毫秒=1000微秒,1微秒=1000纳秒
)
func init()
lastTimeStamp = time.Now().UnixNano() / 1000000
func SetMachineId(mid int64)
// 把机器 id 左移 12 位,让出 12 位空间给序列号使用
machineID = mid << 12
func GetSnowflakeId() int64
curTimeStamp := time.Now().UnixNano() / 1000000
// 同一毫秒
if curTimeStamp == lastTimeStamp
sn++
// 序列号占 12 位,十进制范围是 [ 0, 4095 ]
if sn > 4095
time.Sleep(time.Millisecond)
curTimeStamp = time.Now().UnixNano() / 1000000
lastTimeStamp = curTimeStamp
sn = 0
// 取 64 位的二进制数 0000000000 0000000000 0000000000 0001111111111 1111111111 1111111111 1 ( 这里共 41 个 1 )和时间戳进行并操作
// 并结果( 右数 )第 42 位必然是 0, 低 41 位也就是时间戳的低 41 位
rightBinValue := curTimeStamp & 0x1FFFFFFFFFF
// 机器 id 占用10位空间,序列号占用12位空间,所以左移 22 位; 经过上面的并操作,左移后的第 1 位,必然是 0
rightBinValue <<= 22
id := rightBinValue | machineID | sn
return id
if curTimeStamp > lastTimeStamp
sn = 0
lastTimeStamp = curTimeStamp
// 取 64 位的二进制数 0000000000 0000000000 0000000000 0001111111111 1111111111 1111111111 1 ( 这里共 41 个 1 )和时间戳进行并操作
// 并结果( 右数 )第 42 位必然是 0, 低 41 位也就是时间戳的低 41 位
rightBinValue := curTimeStamp & 0x1FFFFFFFFFF
// 机器 id 占用10位空间,序列号占用12位空间,所以左移 22 位; 经过上面的并操作,左移后的第 1 位,必然是 0
rightBinValue <<= 22
id := rightBinValue | machineID | sn
return id
if curTimeStamp < lastTimeStamp
return 0
return 0
main.go
package main
import (
"fmt"
"reflect"
"snowflake"
"time"
)
func main()
//var ids = []int64
var ids = make([]int64, 0)
//设置一个机器标识，如IP编码,防止分布式机器生成重复码
snowflake.SetMachineId(192168100101)
fmt.Println("start", time.Now().Format("13:04:05"))
for i := 0; i < 10000000; i++
id := snowflake.GetSnowflakeId()
ids = append(ids, id)
fmt.Println("end ", time.Now().Format("13:04:05"))
result := Duplicate(ids)
fmt.Println("去重后数量：", len(result))
fmt.Println(result[10], result[11], result[12], result[13], result[14])
fmt.Println(result[9990], result[9991], result[9992], result[9993], result[9994])
//去重
func Duplicate(a interface) (ret []interface)
va := reflect.ValueOf(a)
for i := 0; i < va.Len(); i++
if i > 0 && reflect.DeepEqual(va.Index(i-1).Interface(), va.Index(i).Interface())
continue
ret = append(ret, va.Index(i).Interface())
return ret
注意：在分布式系统中给每台机器设置一个int64的机器码，可以是IP编号+随机数，如
192168011234（192.168.0.1+1234）
测试结果：
结论：
理论上生成速率为kw/秒，所以完全满足一般企业级应用， 算法可靠（去重处理在此也是多此一举）；
性能：100W+/秒；
>参考： https://blog.csdn.net/u011499747/article/details/78254990
雪花算法原理解析(代码片段)
...拆分，设置初始值和相同的自增步长。批量申请自增ID。雪花算法。百度UidGenerator算法(基于雪花算法实现自定义时间戳)。美团Leaf算法(依赖于数据库，ZK)。 本文主要介绍SnowFlake算法，是Twitter开源的分布式id生成算法。 其... 查看详情
雪花算法(代码片段)
雪花算法(snowflake)：用于生成分布式ID（纯数字，时间顺序）,订单编号等自增ID：记录可以根据ID号进行推测出来，对于数据敏感场景不宜使用。GUID：采用无意义字符串，数据量增大时造成访问过慢，且不宜排序。雪花算法描述... 查看详情
6-9雪花算法与新增功能(代码片段)
新增工具类：/***Twitter的分布式自增ID雪花算法**/@ComponentpublicclassSnowFlake/***起始的时间戳*/privatefinalstaticlongSTART_STMP=1609459200000L;//2021-01-0100:00:00/***每一部分占用的位数*/privatefinalstaticlongSEQUEN 查看详情
id生成算法-雪花算法（snowflake）及代码实现(代码片段)
文章目录前言一、ID生成算法对比二、雪花算法原理三、java实现结尾前言唯一ID可以标识数据的唯一性，在分布式系统中生成唯一ID的方案有很多，常见的方式大概有以下三种：依赖数据库，使用如MySQL自增列或Orac... 查看详情
厉害了，美女同事用单例模式实现了雪花算法！(代码片段)
点击关注公众号，Java干货及时送达雪花算法雪花算法适用于生成全局唯一的编号，比如数据库主键id，订单编号等至于为什么叫雪花算法，是因为科学家通过研究认为自然界中不存在两片完全相同的雪花，所... 查看详情
雪花算法生成id(代码片段)
packagecom.shopping.test;/***SnowFlake的结构如下(每部分用-分开):<br>*0-00000000000000000000000000000000000000000-00000-00000-000000000000<br>*1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正... 查看详情
golang实现twitter雪花算法(代码片段)
1/*2*twitter雪花算法golang实现,生成唯一趋势自增id3*保留位:63位4*毫秒时间戳:[62-20]43位,时间范围[1970-01-0100:00:00.000,2248-09-2615:10:22.207]5*机器id:[19-12]8位,十进制范围[0,255]6*序列号:[11-0]12位,十进制范围[0,4095]7*bobo8*/910packagetest1112i 查看详情
雪花算法生成的id，前端无法使用(代码片段)
由于前端Number类型长度不够，所以雪花算法生成的ID，传递给前端就会精度丢失。解决方案：@ConfigurationpublicclassJacksonConfig@Bean@Primary@ConditionalOnMissingBean(ObjectMapper.class)publicObjectMapperja 查看详情
谈谈雪花算法的使用(代码片段)
...个月的ECS用来临时对部分项目扩容。其中一个项目有用到雪花算法来生成Id，这个还是挺OK的。不过发现要在配置文件中手动配置机器码！！配置的时候还要先知道目前配置了那些，这样才可以避免重复。经过了解，除了会有单... 查看详情
snowflake雪花算法详解与实现(代码片段)
...avaLib」关注第一时间阅读最新文章。文章目录背景SnowFlake雪花算法算法实现算法验证算法优缺点注意事项背景现在的服务基本是分布式，微服务形式的，而且大数据量也导致分库分表的产生，对于水平分表就需要保证... 查看详情
java实现雪花算法（snowflake）-生成永不重复的id（源代码+工具类）使用案例(代码片段)
雪花算法是由Twitter公司开源的snowflake(雪花）算法。1、雪花算法的原理雪花算法会生成一个64位的二进制数据，为一个Long型。(转换成字符串后长度最多19)，其基本结构:第一位:为未使用第二部分:41位为毫秒级时间(41位... 查看详情
java实现雪花算法（snowflake）-生成永不重复的id（源代码+工具类）使用案例(代码片段)
雪花算法是由Twitter公司开源的snowflake(雪花）算法。1、雪花算法的原理雪花算法会生成一个64位的二进制数据，为一个Long型。(转换成字符串后长度最多19)，其基本结构:第一位:为未使用第二部分:41位为毫秒级时间(41位... 查看详情
mybatis-plus插入测试以及雪花算法(代码片段)
Mybatis-Plus插入测试以及雪花算法1、导入依赖<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dep 查看详情
springboot中使用雪花算法生成雪花id(代码片段)
目录1、什么是雪花算法2、雪花算法的优缺点3、springboot项目中使用雪花算法使用1、什么是雪花算法雪花算法（Snowflake）是一种生成全局唯一ID的算法，由Twitter公司开发。它可以在分布式系统中生成全局唯一的ID，... 查看详情
结合redis在spring架构体系中使用雪花算法(代码片段)
...。这里记录下在工作中我结合Redis在Spring架构体系中使用雪花算法生成分布式ID的方式。一、代码部分importlombok.extern.slf4j.Slf4j;importorg.springframework.data.redis.core.StringRedisTemplate;importorg.springframework.s 查看详情
雪花算法：分布式唯一id生成利器(代码片段)
...的生成，都是软件开发人员经常会面临的一场景。而雪花算法便是这些场景的一个解决方案。以分布式ID为例，它的生成往往会在唯一性、递增性、高可用性、高性能等方面都有所要求。并且在业务处理时，还要防止... 查看详情
雪花算法如何生成用户id？有什么高明之处？(代码片段)
...注。未来我们一起加油！前言文章目录博主简介前言雪花算法生成用户ID分布式ID生成器分布式ID的特点snowflake算法介绍设计思想snowflake的Go实现Twitter索尼雪花 查看详情
oracleid生成算法——雪花算法(代码片段)
背景近几日，被主键ID生成折磨的不太行，于是就在寻找一种合适的主键生成策略，选择一种合适的主键生成策略，可以大大降低主键ID的维护成本。主键ID生成方法最常用的4种主键ID生成方法UUID：全局唯一性&... 查看详情