關於雪花
雪花(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 { ///
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