学习笔记（雪花算法）

分布式全局唯一ID是什么

日常开发中，我们需要对系统中的各种数据使用 ID 唯一表示，比如用户 ID 对应且仅对应一个人，商品 ID 对应且仅对应一件商品，订单 ID 对应且仅对应一个订单

为什么需要分布式ID：随着系统数据量越来越大，单数据库压力太大无法维持性能，所以可能就需要变成一主多从这样读写分离，随着继续扩大一主多从也无法支撑了。这时就需要分库分表，这样的话就会出现不同库表之间的数据 ID 不能再依赖数据库自增的 ID，而需要外部一种方式生成全局统一的唯一 ID

分布式ID需要满足什么条件

• 唯一性：全局必须唯一
• 高性能：不能在生成 ID 上浪费过多的时间，使其成为功能的性能瓶颈
• 高可用：必须保证可用性
• 趋势递增：这个不是必须的，但是最好还是满足，因为比如 innodb 索引就是按照键值排序的，所以有序性可以让维护索引的效率提高

分布式全局唯一ID解决方案

UUID

Java 本身提供了 UUID，这是一个唯一的字符串，它可以不依赖其他工具在本地生成

优点是：代码实现简单；本地生成，没有性能问题；全球唯一的，数据迁移容易

缺点是：每次生成的 ID 是无序的，不满足趋势递增；UUID 是字符串，而且比较长，占用空间大，查询效率低；ID 没有含义，可读性差

SnowFlake

SnowFlake 生成的是一个 Long 类型的值，Long 类型的数据占用 8 个字节，也就是 64 位。SnowFlake 将 64 进行拆分，每个部分具有不同的含义，当然机器码、序列号的位数可以自定义

优点：本地生成，不依赖中间件。 生成的分布式 ID 足够小，只有 8 个字节，而且是递增的

缺点：时钟回拨问题，强烈依赖于服务器的时间，如果时间出现时间回拨就可能出现重复的 ID，需要保障各个服务器之间的时间是一致的，就能解决这个问题

雪花算法介绍

Snowflake 常称为雪花算法，是 Twitter 开源的分布式 ID 生成算法，生成后是一个 64 字节的 Long 型数值，组成部分引入了时间戳，基本保持了自增。生成的所有的 ID 都是随着时间递增，分布式系统内不会产生重复的 ID。组成结构如下

• 符号位：1 位，不用，二进制中的最高位是符号位，1 表示负数，0 表示正数，由于我们生成的雪花算法都是正整数，所以这里是 0
• 时间戳：41 位，这里的时间戳是表示的是从起始时间算起，到生成 ID 时间所经历的时间戳，也就是(当前时间戳-起始时间戳(固定)) 这里一共是 41 位，范围就是 $2^{41}-1$，这么大的毫秒数转化成时间就是大约 69 年
• 机器码：10 位，这里的 10 位代表工作机器 ID，一共可以部署在 $2^{10}=1024$ 台机器上面，10 位又可以分为前面五位是数据中心 ID（0~31），后面五位是机器 ID（0-31）
• 序列号：12 位，序列位，一共可用 $2^{12}-1$ 共 4096 个数字

雪花算法实现

导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.10</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>org.example</groupId>
    <artifactId>snowflake</artifactId>
    <version>1.0.0</version>
    <name>snowflake</name>
    <description>snowflake</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.25</version>
        </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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

配置文件

server:
  port: 8080

spring:
  application:
    name: snowflake

在 org.example.utils 包下创建 IdGeneratorSnowflake，自己测试即可

package org.example.utils;

import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.net.NetUtil;
import cn.hutool.core.util.IdUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Slf4j
@Component
public class IdGeneratorSnowflake {

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

    /**
     * 构造后开始执行, 加载初始化工作, 获取 workerId
     */
    @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();
        }
    }

    /**
     * 生成 ID
     *
     * @return
     */
    public synchronized long snowflakeId() {
        return snowflake.nextId();
    }

    /**
     * 测试生成雪花算法 ID
     *
     * @param args
     */
    public static void main(String[] args) {
        IdGeneratorSnowflake idGeneratorSnowflake = new IdGeneratorSnowflake();
        long snowflakeId = idGeneratorSnowflake.snowflakeId();
        log.info("snowflakeId: " + snowflakeId);
    }

}