zoukankan      html  css  js  c++  java
  • 雪花算法

    关于雪花

    雪花(snowflake)在自然界中,是极具独特美丽,又变幻莫测的东西:

    1. 雪花属于六方晶系,它具有四个结晶轴,其中三个辅轴在一个基面上,互相以60度的角度相交,第四轴(主晶轴)与三个辅轴所形成的基面垂直;
    2. 雪花的基本形状是六角形,但是大自然中却几乎找不出两朵完全相同的雪花,每一个雪花都拥有自己的独有图案,就象地球上找不出两个完全相同的人一样。许多学者用显微镜观测过成千上万朵雪花,这些研究最后表明,形状、大小完全一样和各部分完全对称的雪花,在自然界中是无法形成的。

    雪花算法:

    雪花算法的原始版本是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编号+随机数,如192168011234192.168.0.1+1234)

    测试结果:

    结论:

    理论上生成速率为kw/秒,所以完全满足一般企业级应用, 算法可靠(去重处理在此也是多此一举);
    性能:100W+/秒;


    >参考: https://blog.csdn.net/u011499747/article/details/78254990
  • 相关阅读:
    蚂蚁变大象:浅谈常规网站是如何从小变大的(八)(转)
    蚂蚁变大象:浅谈常规网站是如何从小变大的(七)(转)
    蚂蚁变大象:浅谈常规网站是如何从小变大的(六)(转)
    蚂蚁变大象:浅谈常规网站是如何从小变大的(五)(转)
    蚂蚁变大象:浅谈常规网站是如何从小变大的(四)(转)
    蚂蚁变大象:浅谈常规网站是如何从小变大的(三)(转)
    简单的Poc Exp编写(上)
    kali渗透windowsXP过程
    [W3bSafe]Metasploit溢出渗透内网主机辅助脚本
    WannaCry勒索病毒全解读,权威修复指南大集合
  • 原文地址:https://www.cnblogs.com/Hollson/p/9116218.html
Copyright © 2011-2022 走看看