分布式ID神器之雪花算法简介

一、简介

　　雪花算法这一在分布式架构中很常见的玩意，但一般也不需要怎么去深入了解，一方面一般个人项目用不到分布式之类的大型架构，另一方面，就算要用到，市面上很多ID生成器也帮我们完成了这项工作。

二、分布式ID的特点

• 全局唯一性

　　　　不能出现有重复的ID标识，这是基本要求。

• 递增性

　　　　确保生成ID对于用户或业务是递增的。

• 高可用性

　　　　确保任何时候都能生成正确的ID。

• 高性能性

　　　　在高并发的环境下依然表现良好。

三、分布式ID的常见解决方案

3.1 UUID

　　Java自带的生成一串唯一随机36位字符串（32个字符串+4个“-”）的算法。它可以保证唯一性，且据说够用N亿年，但是其业务可读性差，无法有序递增。

3.2 SnowFlake

今天的主角雪花算法，它是Twitter开源的由64位整数组成分布式ID，性能较高，并且在单机上递增。 具体参考：https://github.com/twitter-archive/snowflake

3.3 UidGenerator

UidGenerator是百度开源的分布式ID生成器，其基于雪花算法实现。 具体参考：https://github.com/baidu/uid-generator/blob/master/README.zh_cn.md

3.4 Leaf

Leaf是美团开源的分布式ID生成器，能保证全局唯一，趋势递增，但需要依赖关系数据库、Zookeeper等中间件。 具体参考：https://tech.meituan.com/MT_Leaf.html

四、雪花算法

4.1 简介

　　SnowFlake是Twitter公司采用的一种算法，目的是在分布式系统中产生全局唯一且趋势递增的ID。

4.2 组成部分（64bit）

　　1、第一位 占用1bit，其值始终是0，没有实际作用。 

　　2、时间戳 占用41bit，精确到毫秒，总共可以容纳约69年的时间。 

　　3、工作机器id 占用10bit，其中高位5bit是数据中心ID，低位5bit是工作节点ID，做多可以容纳1024个节点。 4.序列号 占用12bit，每个节点每毫秒0开始不断累加，最多可以累加到4095，一共可以产生4096个ID。

　　SnowFlake算法在同一毫秒内最多可以生成多少个全局唯一ID呢：： 同一毫秒的ID数量 = 1024 X 4096 = 4194304。

 

4.3 雪花算法的实现

　　雪花算法的实现主要依赖于数据中心ID和数据节点ID这两个参数，具体实现如下。

4.3.1 头文件Snowflake.h

　　源码如下：

/*
*
* 文件名称：Snowflake.h
* 文件标识：
* 摘    要：通过SnowFlake算法生成一个64位大小的分布式自增长id
*
*/
 
#ifndef __SNOWFLAKE_H__
#define __SNOWFLAKE_H__
 
#include <mutex>
#include <atomic>
 
//#define SNOWFLAKE_ID_WORKER_NO_LOCK
typedef unsigned int UInt;
typedef unsigned long UInt64;
 
#ifdef SNOWFLAKE_ID_WORKER_NO_LOCK
typedef std::atomic<UInt> AtomicUInt;
typedef std::atomic<UInt64> AtomicUInt64;
#else
typedef UInt AtomicUInt;
typedef UInt64 AtomicUInt64;
#endif
 
namespace service{
    class Snowflake
    {
    public:
        Snowflake(void);
        ~Snowflake(void);
 
        void setHostId(UInt HostId)
        {
            m_HostId = HostId;
        }
        void setWorkerId(UInt workerId)
        {
            m_WorkerId = workerId;
        }
        UInt64 GetId()
        {
            return GetDistributedId();
        }
 
    private:
        UInt64 GetTimeStamp();
        UInt64 tilNextMillis(UInt64 lastTimestamp);
        UInt64 GetDistributedId();
 
    private:
 
#ifndef SNOWFLAKE_ID_WORKER_NO_LOCK
        std::mutex mutex;
#endif
 
        /**
        * 开始时间截 (2019-09-30 00:00:00.000)
        */
        const UInt64 twepoch = 1569772800000;
 
        /**
        * worker进程映射id所占的位数
        */
        const UInt workerIdBits = 5;
 
        /**
        * 服务器id所占的位数
        */
        const UInt hostIdBits = 5;
 
        /**
        * 序列所占的位数
        */
        const UInt sequenceBits = 12;
 
        /**
        * worker进程映射ID向左移12位
        */
        const UInt workerIdShift = sequenceBits;
 
        /**
        * 服务器id向左移17位
        */
        const UInt hostIdShift = workerIdShift + workerIdBits;
 
        /**
        * 时间截向左移22位
        */
        const UInt timestampLeftShift = hostIdShift + hostIdBits;
 
        /**
        * 支持的worker进程映射id，结果是31
        */
        const UInt maxWorkerId = -1 ^ (-1 << workerIdBits);
 
        /**
        * 支持的服务器id，结果是31
        */
        const UInt maxHostId = -1 ^ (-1 << hostIdBits);
 
        /**
        * 生成序列的掩码，这里为4095
        */
        const UInt sequenceMask = -1 ^ (-1 << sequenceBits);
 
        /**
        * worker进程映射id(0~31)
        */
        UInt m_WorkerId;
 
        /**
        * 服务器id(0~31)
        */
        UInt m_HostId;
 
        /**
        * 毫秒内序列(0~4095)
        */
        AtomicUInt sequence{ 0 };
 
        /**
        * 上次生成ID的时间截
        */
        AtomicUInt64 lastTimestamp{ 0 };
    };
}
#endif

4.3.2 头文件Snowflake.cpp

　　源码如下：

#include "Snowflake.h"
#include <chrono>
#include <exception>
#include <sstream>
 
namespace service
{
    Snowflake::Snowflake(void)
    {
        m_HostId = 0;
        m_WorkerId = 0;
        sequence = 0;
        lastTimestamp = 0;
    }
 
    Snowflake::~Snowflake(void)
    {
    }
 
    UInt64 Snowflake::GetTimeStamp()
    {
        auto t = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now());
        return t.time_since_epoch().count();
    }
 
    UInt64 Snowflake::tilNextMillis(UInt64 lastTimestamp)
    {
        UInt64 timestamp = GetTimeStamp();
        while (timestamp <= lastTimestamp) {
            timestamp = GetTimeStamp();
        }
        return timestamp;
    }
 
    UInt64 Snowflake::GetDistributedId()
    {
#ifndef SNOWFLAKE_ID_WORKER_NO_LOCK
        std::unique_lock<std::mutex> lock{ mutex };
        AtomicUInt64 timestamp{ 0 };
#else
        static AtomicUInt64 timestamp{ 0 };
#endif
 
        timestamp = GetTimeStamp();
        // 如果当前时间小于上一次ID生成的时间戳,说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            std::ostringstream s;
            s << "clock moved backwards.  Refusing to generate id for " << lastTimestamp - timestamp << " milliseconds";
            throw std::exception(std::runtime_error(s.str()));
        }
 
        if (lastTimestamp == timestamp) {
            // 如果是同一时间生成的，则进行毫秒内序列
            sequence = (sequence + 1) & sequenceMask;
            if (0 == sequence) {
                // 毫秒内序列溢出, 阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        else {
            sequence = 0;
        }
 
#ifndef SNOWFLAKE_ID_WORKER_NO_LOCK
        lastTimestamp = timestamp;
#else
        lastTimestamp = timestamp.load();
#endif
 
        // 移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift)
            | (m_HostId << hostIdShift)
            | (m_WorkerId << workerIdShift)
            | sequence;
    }
}

五、参考文章

https://www.cnblogs.com/ForestCherry/p/13217802.html

https://zhuanlan.zhihu.com/p/85837641