雪花算法【snowflake】

最新推荐文章于 2024-07-16 12:45:05 发布

ゞ浪人与酒丶0

最新推荐文章于 2024-07-16 12:45:05 发布

阅读量938

点赞数 2

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/qq_41977838/article/details/108719310

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

雪花算法

在这里插入图片描述
为什么需要分布式全局唯一ID 以及分布式ID的业务需求？

在复杂分布式系统中，往往需要对大量对数据和消息进行标识
如在美团、支付、餐饮中系统的数据日渐增长，对数据分库分表需要有一个唯一来标识一条数据或消息
此时一个能够生成全局唯一ID的系统是非常有必要的

ID生成规则部分硬性要求

全局唯一：不能出现重复的ID，要唯一标识
趋势递增：在Mysql 的InnoDB引擎使用的是聚集索引，由于多数RDBMS 使用的是Btree数据结构来存储数据，在主键的选择上面我们应该尽量使用有序的主键保证数据写入
单调递增：保证下一个ID一定大于上一个ID，例如事物版本号，增量消息
信息安全：如果ID是连续的，恶意用户的扒取数据就非常容易来，直接按照顺序下载指定的URL，如果是订单号就更危险来，竞争对手可以知道我们一天的单量，所以在一些应用场景下，需要ID不规则
含时间戳：这样就能够在开发中快速了解这个分布式id的生成时间

ID生成系统的可用性要求

高可用：发一个获取分布式ID的请求，服务器就要保证99.99%的情况下给我创建一个唯一分布式ID
低延迟：发一个获取分布式ID的请求，服务器就是要快，极速
高QPS ：假如并发一口气10万个创建分布式ID请求同时杀过来，服务器要顶的住一下子成功创建10w个分布式ID

我们平时的方案

UUID 、数据库自增主键、基于Redis 生成全局ID策略

弊端

UUID 不能生成顺序，递增的数据，并且长，不是很推荐

数据库自增，集群多的情况下，扩容简直就是噩梦

Redis 使用Redis INCR 和 INCRBY 实现

snowflake（雪花算法）

Twitter的分布式自增ID算法：snowflake（雪花算法）

概述

最初 Twitter把存储系统从Mysql 迁移到 Cassandra (由Facebook 开发一套开源分布式Nosql系统) 因为Cassandra没有顺序ID生成机制，所以开发成了这样一套全局唯一 ID生成服务

Twitter 的分布式雪花算法SnowFlake ，经测试 snowflake 每秒能产出26 万个自增可排序的ID

twitter的SnowFlake生成ID能够按照时间有序生成
SnowFlake 算法生成id 的结果是一个64 bit 大小的整数，为一个Long 型（转换成字符后长度19位）
分布式系统不会产生ID碰撞（由datacenter 和 workerld 区分）并且效率较高

结构

在这里插入图片描述

号段解析：

1bit ，

不用，因为二进制中最高位是符号位，毫秒级，生成的id一般用整数，所以最高位 0

41bit - 时间戳，用来记录时间戳，毫秒级，

41位可以表示 2 ^ {41}-1个数字
如果只用来表示正整数(计算机中正整数包含0)。可以表示数值范围：0 至 2^{41}-1 , 减1 是因为表示的数值是从0开始算的，而不是1.
也就是说 41 位可以表示 2 ^ {41}-1 个毫秒的值，装换成单位年则（2^{41}-1）/ （1000 * 60 * 60 * 24 * 365）=69年

10bit- 工作机器ID，用来记录工作机器ID

可以部署在 2^{10} = 1024 个节点，包括5位 datacenterId 和 5位的 workeId
5位（bit）可以表示的最大正整数是 2 ^ {5}-1 =31 , 即可以用0、1、2、3…31这32个数字，来表示不同的datacenterId 或者 workId

12 bit -序列号，序列号，用来记录同毫秒内产生的不同的id。

12位可以表示的最大正整数是2^{12}-1 = 4095 即可以用0、1、2、34094 这 4095个数字来表示同一机器同一时间（毫秒）产生的4095个ID序号

SnowFlake可以保证

所有生成的id 按时间趋势递增
整个分布式系统内不会产生重复的id

源码

twitter的雪花算法：https://github.com/twitter-archive/snowflake

GitHub上java版的雪花算法：
https://github.com/beyondfengyu/SnowFlake/blob/master/SnowFlake.java
https://github.com/souyunku/SnowFlake/blob/master/SnowFlake.java

java版❄️雪花算法

public class SnowflakeIdWorker {
 // ==============================Fields==================
    /** 开始时间截 (2019-08-06) */
    private final long twepoch = 1565020800000L;
 
    /** 机器id所占的位数 */
    private final long workerIdBits = 5L;
 
    /** 数据标识id所占的位数 */
    private final long datacenterIdBits = 5L;
 
    /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
 
    /** 支持的最大数据标识id，结果是31 */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
 
    /** 序列在id中占的位数 */
    private final long sequenceBits = 12L;
 
    /** 机器ID向左移12位 */
    private final long workerIdShift = sequenceBits;
 
    /** 数据标识id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;
 
    /** 时间截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
 
    /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
 
    /** 工作机器ID(0~31) */
    private long workerId;
 
    /** 数据中心ID(0~31) */
    private long datacenterId;
 
    /** 毫秒内序列(0~4095) */
    private long sequence = 0L;
 
    /** 上次生成ID的时间截 */
    private long lastTimestamp = -1L;
 
     //==============================Constructors====================
    /**
     * 构造函数
     * @param workerId 工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowflakeIdWorker(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
 
    // ==============================Methods=================================
    /**
     * 获得下一个ID (该方法是线程安全的)
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
 
        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(
                    String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
 
        //如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            //毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        //时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }
 
        //上次生成ID的时间截
        lastTimestamp = timestamp;
 
        //移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }
 
    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }
 
    /**
     * 返回以毫秒为单位的当前时间
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }
 
    //==============================Test=============================================
    /** 测试 */
    public static void main(String[] args) {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 10; i++) {
            long id = idWorker.nextId();
            System.out.println(Long.toBinaryString(id));
            System.out.println(id);
        }
    }
}

springboot整合雪花算法

新建项目snowflake
pom

<dependencies>
    <!--hutool 引入糊涂工具包，测试雪花算法-->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-captcha</artifactId>
        <version>5.3.8</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

server:
  port: 7777

新建 utils包 IdGeneratorSnowflake 类

@Slf4j
@Component
public class IdGeneratorSnowflake {

    private long workerId = 0;  //第几号机房
    private long datacenterId = 1;  //第几号机器
    private Snowflake snowflake = IdUtil.createSnowflake(workerId, datacenterId);

    @PostConstruct  //构造后开始执行，加载初始化工作
    public void init(){
        try{
            //获取本机的ip地址编码
            workerId = NetUtil.ipv4ToLong(NetUtil.getLocalhostStr());
            log.info("当前机器的workerId: " + workerId);
        }catch (Exception e){
            e.printStackTrace();
            log.warn("当前机器的workerId获取失败 ----> " + e);
            workerId = NetUtil.getLocalhostStr().hashCode();
        }
    }

    public synchronized long snowflakeId(){
        return snowflake.nextId();
    }

    public synchronized long snowflakeId(long workerId, long datacenterId){
        Snowflake snowflake = IdUtil.createSnowflake(workerId, datacenterId);
        return snowflake.nextId();
    }

    //测试
    public static void main(String[] args) {
        System.out.println(new IdGeneratorSnowflake().snowflakeId());   //1277896081711169536
    }
}

新建service包 OrderService 接口与 service.impl包 OrderServiceImpl 实现OrderService的接口

public interface OrderService {

    String getIDBySnowFlake();
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private IdGeneratorSnowflake idGenerator;

    public String getIDBySnowFlake() {
        //新建线程池（5个线程）
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        for (int i = 1; i <= 20; i++) {
            threadPool.submit(() -> {
                System.out.println(idGenerator.snowflakeId());
            });
        }

        threadPool.shutdown();

        return "hello snowflake";
    }
}

新建 controller 包 OrderController

@RestController
public class OrderController {

    @Autowired
    private OrderService orderService;

    @RequestMapping("/snowflake")
    public String index(){
        return orderService.getIDBySnowFlake();
    }

}

主启动类

@SpringBootApplication
public class MainApp {
    public static void main(String[] args) {
        SpringApplication.run(MainApp.class, args);
    }
}

启动项目浏览器输入http://localhost:7777/snowflake

在这里插入图片描述

优缺点

在这里插入图片描述

解决时钟回拨问题

百度开源的分布式唯一ID生成器 UidGenerator
美团开源的分布式ID生成系统 Leaf
个人博客：http://blog.yanxiaolong.cn/

ゞ浪人与酒丶0

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
雪花算法【snowflake】

雪花算法为什么需要分布式全局唯一ID 以及分布式ID的业务需求？在复杂分布式系统中，往往需要对大量对数据和消息进行标识如在美团、支付、餐饮中系统的数据日渐增长，对数据分库分表需要有一个唯一来标识一条数据或消息此时一个能够生成全局唯一ID的系统是非常有必要的ID生成规则部分硬性要求全局唯一：不能出现重复的ID，要唯一标识趋势递增：在Mysql 的InnoDB引擎使用的是聚集索引，由于多数RDBMS 使用的是Btree数据结构来存储数据，在主键的选择上面我们应该尽量使用有序的主键
复制链接

扫一扫

专栏目录