Spring Boot基于Zookeeper和Snowflake生成唯一ID完整版

- 一、简介
- 二、maven依赖
- 三、配置
- - 3.1、属性配置文件
  - 3.2、属性配置类
  - 3.3、zookeeper配置类（核心）
- 四、详细使用
- - 4.1、zookeeperClient（核心）
  - 4.2、Snowflake算法（核心）
  - 4.3、dataCenterId定义
  - 4.4、service层（核心实现）
  - 4.5、controller层
- 五、测试
- - 5.1、多实例
  - 5.2、nginx转发配置
  - 5.3、使用jmeter并发测试
  - 5.4、测试结果
- 六、Snowflake优缺点
- - 6.1、优点
  - 6.2、缺点
- 结语

一、简介

zookeeper是一个分布式的，开放源码的分布式应用程序协调服务，它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。选择zookeeper的原因，因为zookeeper具有以下优点：

可靠性：如果消息被到一台服务器接受，那么它将被所有的服务器接受。
实时性：在一定事件范围内，client能读到最新数据，如果需要最新数据，应该在读数据之前调用sync()接口
独立性：各个Client之间互不干预
顺序性：更新请求顺序进行，来自同一个client的更新请求按其发送顺序依次执行
原子性：一次数据的更新只能成功或者失败，没有其他中间状态
最终一致性：全局唯一数据视图，client无论连接到哪个server，数据视图都是一致的

snowflake在单机环境使用是简单高效，但是实际中遇到分布式，容器各种环境下，需要考虑的东西还是蛮多的，今天我们就实现一个简单版的。

二、maven依赖

pom.xml



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.5.2
         
    
    com.alian
    snowflake
    0.0.1-SNAPSHOT
    snowflake
    Demo project for Spring Boot
    
        1.8
    
    
        
        
            org.springframework.boot
            spring-boot-starter-web
            ${parent.version}
        

        
            org.apache.zookeeper
            zookeeper
            3.6.3
            
                
                    org.slf4j
                    slf4j-log4j12
                
                
                    org.slf4j
                    slf4j-api
                
                
                    log4j
                    log4j
                
            
        

        
            org.apache.curator
            curator-framework
            5.2.0
            
                
                    org.apache.zookeeper
                    zookeeper
                
                
                    org.slf4j
                    slf4j-api
                
            
        

        
            org.apache.curator
            curator-recipes
            5.2.0
            
                
                    org.apache.zookeeper
                    zookeeper
                
            
        

        
            org.projectlombok
            lombok
            1.16.14
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

我这里把zookeeper里面的日志框架都过滤了，加入了lombok，你们可以根据自己的需要进行相应的处理。

三、配置 3.1、属性配置文件

我们在resource目录下建一个config文件夹，然后在config目录下创建zookeeper的自定义配置文件zookeeper.properties，主要是zookeeper连接和目录相关的配置，因为本机的配置原因，我这里就没有采用zookeeper的集群模式了，Zookeeper建议集群节点个数为奇数（大于等于3），只要超过一半的机器能够正常提供服务，那么整个集群都是可用的状态。

zookeeper.properties

# zookeeper服务器地址（ip+port）
zookeeper.server=10.130.3.16:2181
#zookeeper.server=192.168.0.101:2181
# 节点创建的路径约定用"/"结尾
zookeeper.rootPath=/root/alian/
# 锁路径
zookeeper.lockPath=/root/snowflake
# 休眠时间
zookeeper.sleep-time=1000
# 最大重试次数
zookeeper.max-retries=3
# 会话超时时间
zookeeper.session-timeout=5000
# 连接超时时间
zookeeper.connection-timeout=5000

3.2、属性配置类

ZookeeperProperties.java

package com.alian.snowflake.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Data
@Component
@ConfigurationProperties(prefix = "zookeeper")
@PropertySource(value = "classpath:config/zookeeper.properties", encoding = "UTF-8", ignoreResourceNotFound = true)//读取指定路径配置文件,暂不支持*.yaml文件
public class ZookeeperProperties {

    
    private String server;

    
    private String rootPath;

    
    private String lockPath;

    
    private int sleepTime;

    
    private int maxRetries;

    
    private int sessionTimeout;

    
    private int connectionTimeout;

}

此配置类不懂的可以参考我另一篇文章：Spring Boot读取配置文件常用方式

3.3、zookeeper配置类（核心）

为什么要使用Curator，因为Curator提供了简化使用zookeeper更高级的API接口，Curatorframework实例都是线程安全的。它包涵很多优秀的特性：

自动连接管理：自动处理zookeeper的连接和重试存在一些潜在的问题，可以监控节点数据改变和获取更新服务的列表，而监控又可以自动被Cruator recipes删除
更简洁的API：提供现代流式API接口，简化了原生zookeeper方法，事件等
Recipe实现：可以应用到leader选举，分布式锁，path缓存，和watcher，分布式队列等

ZookeeperConfig.java

package com.alian.snowflake.config;

import com.alian.snowflake.common.ZookeeperClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.Curatorframework;
import org.apache.curator.framework.CuratorframeworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class ZookeeperConfig {

    @Autowired
    private ZookeeperProperties zookeeperProperties;

    @Bean
    public Curatorframework curatorframeworkClient() {
        //重试策略,ExponentialBackoffRetry(1000,3)这里表示等待1s重试，最大重试次数为3次
        RetryPolicy policy = new ExponentialBackoffRetry(zookeeperProperties.getSleepTime(), zookeeperProperties.getMaxRetries());
        //构建Curatorframework实例
        Curatorframework curatorframeworkClient = CuratorframeworkFactory
                .builder()
                .connectString(zookeeperProperties.getServer())
                .sessionTimeoutMs(zookeeperProperties.getSessionTimeout())
                .connectionTimeoutMs(zookeeperProperties.getConnectionTimeout())
                .retryPolicy(policy)
                .build();
        //启动实例
        curatorframeworkClient.start();
        return curatorframeworkClient;
    }

    @Bean(destroyMethod = "destroy")
    public ZookeeperClient zookeeperClient(ZookeeperProperties zookeeperProperties, Curatorframework curatorframeworkClient) {
        return new ZookeeperClient(zookeeperProperties, curatorframeworkClient);
    }

}

四、详细使用 4.1、zookeeperClient（核心）

此组件主要是完成，顺序节点的创建，我这里创建的是临时顺利节点。我想我代码的注释比这个惨白的文字要更有说服力。很多小伙伴可能会采用@Component注解，我使用@Bean(destroyMethod = “destroy”)来创建，可以比较优雅的关闭连接，当然在使用上是一样的，只要不是对一个bean同时使用@Component 和 @Bean。
zookeeperClient.java

package com.alian.snowflake.common;

import com.alian.snowflake.config.ZookeeperProperties;
import com.sun.istack.internal.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.Curatorframework;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;

@Slf4j
public class ZookeeperClient {

    private ZookeeperProperties zookeeperProperties;

    private Curatorframework curatorframework;

    public Curatorframework getCuratorframework() {
        return curatorframework;
    }

    public ZookeeperClient(ZookeeperProperties zookeeperProperties, Curatorframework curatorframework) {
        this.zookeeperProperties = zookeeperProperties;
        this.curatorframework = curatorframework;
    }

    public void destroy() {
        try {
            log.info("ZookeeperClient销毁方法，如果zookeeper连接不为空，则关闭连接");
            if (getCuratorframework() != null) {
                //这种方式比较优雅的关闭连接
                getCuratorframework().close();
            }
        } catch (Exception e) {
            log.error("stop zookeeper client error {}", e.getMessage());
        }
    }

    
    public String generateId(String nodeName) {
        //创建临时自动编号的顺序节点,返回的是一个路径
        String nodeFullPath = createSeqNode(nodeName);
        if (null == nodeFullPath) {
            return "";
        }
        String generateId = splitSeqNode(nodeFullPath);
        log.info("节点编号：" + generateId);
        return generateId;
    }

    
    private String createSeqNode(@NotNull String nodePrefix) {
        if ("".equals(nodePrefix.trim()) || nodePrefix.startsWith("/") || nodePrefix.endsWith("/")) {
            log.error("节点前缀错误");
            return "";
        }
        String nodeFullPath = "";
        //根路径+要创建节点的名称（可以是路径，此处传入的nodeName不要用"/"开头或结尾）
        String fullPath = zookeeperProperties.getRootPath().concat(nodePrefix);
        try {
            //关键点：创建临时顺序节点
            //creatingParentsIfNeeded():如果传入的是路径，并且节点父路径不存在则创建父节点
            nodeFullPath = curatorframework
                    .create()
                    .creatingParentsIfNeeded()
                    .withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
                    .forPath(fullPath);
        } catch (Exception e) {
            log.error("创建临时顺序节点异常{}", e.getMessage());
            e.printStackTrace();
        }
        return nodeFullPath;
    }

    private String splitSeqNode(String path) {
        //获取最后一个"/"的索引，用于字符串截取
        int index = path.lastIndexOf("/");
        if (index >= 0) {
            //如果"/"位置比路径长度小，则截取"/"后面的作为节点返回
            //如果"/"位置等于路径长度，说明它后面没有元素，返回空字符串
            return index <= path.length() ? path.substring(index + 1) : "";
        }
        //不含"/"，说明是节点数据，直接返回（理论上不会，因为都是"/"开头的路径，至少有一个"/"）
        return path;
    }

	//删除节点
    public void deleteTheNode(String fullNodePath) {
        try {
            Stat stat = curatorframework.checkExists().forPath(fullNodePath);
            if (stat != null) {
                curatorframework.delete().forPath(fullNodePath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public List getChildren(String path) {
        try {
            List childrenList = curatorframework.getChildren().forPath(path);
            if (childrenList != null && childrenList.size() > 0) {
                return childrenList;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Collections.emptyList();
    }

}

关于zookeeper里节点的模式，新版又增加了两个带TTL的持久化节点，节点模式：

PERSISTENT：持久化节点
PERSISTENT_SEQUENTIAL：持久化的顺序自动编号节点
EPHEMERAL：临时节点
EPHEMERAL_SEQUENTIAL：临时顺序自动编号节点
CONTAINER：容器节点
PERSISTENT_WITH_TTL：带TTL（time-to-live，存活时间）的持久化节点，节点在TTL时间之内没有得到更新并且没有子节点，就会被自动删除
PERSISTENT_SEQUENTIAL_WITH_TTL：带TTL（time-to-live，存活时间）和单调递增序号的持久节点，节点在TTL时间之内没有得到更新并且没有子节点，就会被自动删除

4.2、Snowflake算法（核心）

要了解snowflake算法，首先得了解它的结构

第一位：占用1bit，其值始终是0，没有实际作用
时间戳：占用41bit，精确到毫秒，总共可以容纳约69年的时间（(1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69）
工作机器id：占用10bit，最多可以容纳1024个节点（可以改造为5位工作中心+5位数据中心，具体如上图第二部分）
序列号：占用12bit，最多可以累加到4095。这个值在同一毫秒同一节点上从0开始不断累加。

Snowflake算法是开源的如下：

Snowflake.java

package com.alian.snowflake.common;


public class Snowflake {

    
    private final long startTimestamp = 1636560000000L;//开始时间截 (2021-11-11)
    private long dataCenterId;//数据中心ID(0~31)
    private long workerId;//工作机器ID(0~31)
    private long sequence = 0L;//毫秒内序列(0~4095)
    private long lastTimestamp = -1L;//上次生成ID的时间截

    
    private final long dataCenterIdBits = 5L;//数据标识id所占的位数
    private final long workerIdBits = 5L;//机器id所占的位数
    private final long sequenceBits = 12L;//序列在id中占的位数

    
    private final long maxDataCenterId = ~(-1L << dataCenterIdBits);//支持的最大数据标识id，结果是31
    private final long maxWorkerId = ~(-1L << workerIdBits);//支持的最大机器id，结果是31
    private final long sequenceMask = ~(-1L << sequenceBits);//生成序列的掩码，这里为4095

    
    private final long timestampLeftShift = sequenceBits + workerIdBits + dataCenterIdBits;//时间截向左移22位(5+5+12)
    private final long dataCenterIdShift = sequenceBits + workerIdBits;//数据标识id向左移17位(12+5)
    private final long workerIdShift = sequenceBits;//机器ID向左移12位

    
    public Snowflake(long dataCenterId, long workerId) {
        if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDataCenterId));
        }
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }

    
    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 - startTimestamp) << timestampLeftShift) //
                | (dataCenterId << dataCenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }

    
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    
    protected long timeGen() {
        return System.currentTimeMillis();
    }

}

4.3、dataCenterId定义

SystemSequence.java

package com.alian.snowflake.common;

public class SystemSequence {

    
    public static final long PAY = 0;

    
    public static final long QUERY = 1;

    
    public static final long NOTICE = 2;

    
    public static final long SNOWFLAKE = 4;

    
    public static final long OMS = 5;

    
    public static final long AMS = 6;

}

改造后的工作中心id最大为31（2的5次方），也就是可以有32个系统。当然一般这种定义文件一般是公共包或者存数据库，我这里只是一个事例，为了本文的阅读性。

4.4、service层（核心实现）

DistributedService.java

package com.alian.snowflake.service;

import com.alian.snowflake.common.Snowflake;
import com.alian.snowflake.common.SystemSequence;
import com.alian.snowflake.common.ZookeeperClient;
import com.alian.snowflake.config.ZookeeperProperties;
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Slf4j
@Service
public class DistributedService {

    private Snowflake idWorker = null;

    @Autowired
    private ZookeeperProperties zookeeperProperties;

    @Autowired
    private ZookeeperClient zookeeperClient;

    
    @PostConstruct
    private void init() {
        //获取锁路径
        String lockPath = zookeeperProperties.getLockPath();
        //创建InterProcessMutex实例
        InterProcessMutex lock = new InterProcessMutex(zookeeperClient.getCuratorframework(), lockPath);
        boolean success = false;
        try {
            success = lock.acquire(20, TimeUnit.SECONDS);
            if (success) {
                initSnowflake();
            }
        } catch (Exception e) {
            log.error("snowflake系统启动初始化方法异常", e);
        } finally {
            try {
                if (success) {
                    lock.release();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void initSnowflake() {
        boolean create = true;
        do {
            //也可以是  xxx/id-
            String nodeName = "snowflake/id-";
            //生成节点的完整路径
            String fullPath = zookeeperProperties.getRootPath() + nodeName;
            //截取开始到最后一个/作为父路径
            String path = fullPath.substring(0, fullPath.lastIndexOf("/"));
            //获取路径下所有子节点
            List children = zookeeperClient.getChildren(path);
            log.info("{}", children);
            if (children.size() >= 32) {
                log.error("节点已经超过32个了");
                throw new RuntimeException();
            }
            //生成唯一id
            String generateId = zookeeperClient.generateId(nodeName);
            log.info("zookeeper生成的原始id：{}", generateId);
            //去除前缀id-
            long workerId = Long.parseLong(generateId.substring(3)) % 32;
            if (children.size() > 0) {
                //路径下的所有节点转为long型并对对32求模
                List collect = children.stream().map(p -> Long.parseLong(p.substring(3)) % 32).collect(Collectors.toList());
                if (!collect.contains(workerId)) {
                    //求模后列表里不重复
                    create = false;
                    //实例化
                    idWorker = new Snowflake(SystemSequence.SNOWFLAKE, workerId);
                } else {
                    //workerId占用的可以删除节点
                    zookeeperClient.deleteTheNode(path + "/" + generateId);
                }
            } else {
                create = false;
                idWorker = new Snowflake(SystemSequence.SNOWFLAKE, workerId);
            }
        } while (create);
    }

    public String generateId() {
        //我这里就不做严格的判断了
        if (idWorker == null) {
            return "";
        }
        return "" + idWorker.nextId();
    }
}

在这里我们要解释下一段代码：

	idWorker = new Snowflake(SystemSequence.SNOWFLAKE, workerId);

SystemSequence是我们定义的一个系统一个编号，不管是单机还是多实例，同一个系统不管是第一次启动还是第二次启动，都是不会变的，编号是从0开始到31，相当于是一个固定的值。而workerId是我们通过zookeeper生成的，具有顺序性和唯一性。比如从0000000000~9999999999，我这里实现的基本流程图如下：

我大概介绍下我们实现的基本流程

整个初始化的流程中我使用curator分布式锁
首先我们定义一个节点的前缀，我建议每个系统带不同的前缀比如pay/id-、query/id-、snowflake/id-，这样有个好处就是每个系统的节点都在一起便于分析节点，如果所有系统都在一起，那么你还得去分析节点的值才能判断节点是否可用
获取生成节点的父路径下的所有的子节点，如果节点的数目大于等于32，说明实例数已经满了，不能创建了，因为本文这里的workerId最大是31
当子节点数目小于32，我们创建一个新的临时顺序节点，去除节点的前缀后，用32对其求模（得到的workerId就是1~31）
如果子节点的数目大于0，小于32，我们把子节点里是数据都转为long型，并对用32对其求模
判断计算后的workerId是否在求模后的列表中，如果workerId在列表中，说明workerId已经占用，则删除节点后，继续循环上述流程，如果workerId不在求模后的列表中，直接初始化snowflake
还有就是如果节点列表为空，说明还没有实例启动，则创建一个新的临时顺序节点，去除节点的前缀后，对32求模，然后初始化snowflake

关于curator分布式锁不懂的可以参考：SpringBoot基于Zookeeper和Curator实现分布式锁并分析其原理

但是为什么要对该数据求模呢？

首先我们知道workerId最大31，举个例子，我们系统每次启动就会生成一个唯一id，假设我们的实例部署了,31个（生成的节点编号是0000000000~0000000030），然后假设第30号服务重启了一次，重启时生成的节点编号是0000000031，这个时候，我们应该还可以部署一个新的服务，或者对任意一个系统进行重启，对吧？不管是新的服务，还是重启生成的编号是不是编号就是0000000032，这个32我们的snowflake肯定是接收不不了的，因为它的范围是0到31
假设我们是第3台机器重启了，那么求模后的数为0，明显0已经被第一号机器占用了，我们只能继续生成节点，直到生成0000000034节点，求模后是2，也就是3号机器（3号机器重启时0000000002节点已经自动删除了），这下大家应该知道为什么对32求模了吧？

4.5、controller层

简单的一个获取id的接口，仅仅是为了演示，实际中肯定更加严格和规范。

DistributedIdController.java

package com.alian.snowflake.controller;

import com.alian.snowflake.service.DistributedService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

@Slf4j
@RestController
@RequestMapping("/distributed")
public class DistributedIdController {

    @Autowired
    private DistributedService distributedService;

    
    @RequestMapping("/generateId")
    public String generateId(HttpServletRequest request) {
        String distributedId = distributedService.generateId();
        log.info("获取到的分布式id:{}", distributedId);
        return distributedId;
    }
}

五、测试 5.1、多实例

由于我们是windows环境下的本机开发及测试，我们使用idea启动三个实例进行负载均衡，端口分别为6061、6062、6063。

application.yml

server:
  port: 6061
  servlet:
    context-path: /snowflake

三个实例启动的示例图：

5.2、nginx转发配置

自定义配置文件localhost_80.conf里server模块里增加转发配置，通过负载均衡到两个实例上。

	location ~ ^/snowflake/ {
        proxy_redirect off;
		#端口
        proxy_set_header Host $host;
		#远程地址
        proxy_set_header X-Real-IP $remote_addr;
		#程序可获取远程ip地址
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		#此处会用的upstream.conf,此文件在nginx.conf已经引入了
        proxy_pass http://snowflake;
    }

负载均衡配置upstream.conf文件增加下面的配置，其中snowflake 就是localhost_80.conf文件里配置的http://snowflake;

	upstream snowflake {
	    server 127.0.0.1:6061 ;
		server 127.0.0.1:6062 ;
		server 127.0.0.1:6063 ;
	}

如果你的nginx已经启动，最后记得使用命令 nginx -t 检查和 nginx -s reload 应用。如果不懂的可以参考我另一篇文章：windows下Nginx配置及负载均衡使用

5.3、使用jmeter并发测试

本文中使用使用100个线程请求我的接口获取id，150表示线程数，0表示0秒内一起发送，1表示请求循环的次数。

我们请求的地址是：http://localhost/snowflake/distributed/generateId，注意是没有端口的，会通过nginx转发到后台实例。

5.4、测试结果

端口为6061实例的结果：

2021-11-17 17:38:54 170 [http-nio-6061-exec-24] INFO generateId 27:获取到的分布式id:2440808817528832
2021-11-17 17:38:54 170 [http-nio-6061-exec-8] INFO generateId 27:获取到的分布式id:2440808817528836
2021-11-17 17:38:54 171 [http-nio-6061-exec-26] INFO generateId 27:获取到的分布式id:2440808821723136
2021-11-17 17:38:54 170 [http-nio-6061-exec-3] INFO generateId 27:获取到的分布式id:2440808817528835
2021-11-17 17:38:54 171 [http-nio-6061-exec-1] INFO generateId 27:获取到的分布式id:2440808821723140
2021-11-17 17:38:54 171 [http-nio-6061-exec-2] INFO generateId 27:获取到的分布式id:2440808821723139
2021-11-17 17:38:54 171 [http-nio-6061-exec-22] INFO generateId 27:获取到的分布式id:2440808821723138
2021-11-17 17:38:54 170 [http-nio-6061-exec-40] INFO generateId 27:获取到的分布式id:2440808817528833
2021-11-17 17:38:54 170 [http-nio-6061-exec-34] INFO generateId 27:获取到的分布式id:2440808817528834
2021-11-17 17:38:54 171 [http-nio-6061-exec-49] INFO generateId 27:获取到的分布式id:2440808821723143
2021-11-17 17:38:54 171 [http-nio-6061-exec-29] INFO generateId 27:获取到的分布式id:2440808821723146
2021-11-17 17:38:54 171 [http-nio-6061-exec-48] INFO generateId 27:获取到的分布式id:2440808821723144
2021-11-17 17:38:54 171 [http-nio-6061-exec-17] INFO generateId 27:获取到的分布式id:2440808821723145
2021-11-17 17:38:54 171 [http-nio-6061-exec-36] INFO generateId 27:获取到的分布式id:2440808821723142
2021-11-17 17:38:54 171 [http-nio-6061-exec-20] INFO generateId 27:获取到的分布式id:2440808821723137
2021-11-17 17:38:54 172 [http-nio-6061-exec-35] INFO generateId 27:获取到的分布式id:2440808825917441
2021-11-17 17:38:54 172 [http-nio-6061-exec-4] INFO generateId 27:获取到的分布式id:2440808825917442
2021-11-17 17:38:54 172 [http-nio-6061-exec-38] INFO generateId 27:获取到的分布式id:2440808825917443
2021-11-17 17:38:54 171 [http-nio-6061-exec-43] INFO generateId 27:获取到的分布式id:2440808821723141
2021-11-17 17:38:54 172 [http-nio-6061-exec-41] INFO generateId 27:获取到的分布式id:2440808825917448
2021-11-17 17:38:54 172 [http-nio-6061-exec-11] INFO generateId 27:获取到的分布式id:2440808825917447
2021-11-17 17:38:54 172 [http-nio-6061-exec-13] INFO generateId 27:获取到的分布式id:2440808825917449
2021-11-17 17:38:54 172 [http-nio-6061-exec-28] INFO generateId 27:获取到的分布式id:2440808825917440
2021-11-17 17:38:54 172 [http-nio-6061-exec-44] INFO generateId 27:获取到的分布式id:2440808825917444
2021-11-17 17:38:54 173 [http-nio-6061-exec-31] INFO generateId 27:获取到的分布式id:2440808830111744
2021-11-17 17:38:54 173 [http-nio-6061-exec-16] INFO generateId 27:获取到的分布式id:2440808830111745
2021-11-17 17:38:54 173 [http-nio-6061-exec-9] INFO generateId 27:获取到的分布式id:2440808830111746
2021-11-17 17:38:54 172 [http-nio-6061-exec-39] INFO generateId 27:获取到的分布式id:2440808825917446
2021-11-17 17:38:54 173 [http-nio-6061-exec-27] INFO generateId 27:获取到的分布式id:2440808830111747
2021-11-17 17:38:54 173 [http-nio-6061-exec-37] INFO generateId 27:获取到的分布式id:2440808830111750
2021-11-17 17:38:54 173 [http-nio-6061-exec-12] INFO generateId 27:获取到的分布式id:2440808830111749
2021-11-17 17:38:54 173 [http-nio-6061-exec-18] INFO generateId 27:获取到的分布式id:2440808830111748
2021-11-17 17:38:54 173 [http-nio-6061-exec-7] INFO generateId 27:获取到的分布式id:2440808830111751
2021-11-17 17:38:54 172 [http-nio-6061-exec-19] INFO generateId 27:获取到的分布式id:2440808825917445
2021-11-17 17:38:54 173 [http-nio-6061-exec-10] INFO generateId 27:获取到的分布式id:2440808830111752
2021-11-17 17:38:54 173 [http-nio-6061-exec-15] INFO generateId 27:获取到的分布式id:2440808830111753
2021-11-17 17:38:54 173 [http-nio-6061-exec-50] INFO generateId 27:获取到的分布式id:2440808830111754
2021-11-17 17:38:54 173 [http-nio-6061-exec-46] INFO generateId 27:获取到的分布式id:2440808830111756
2021-11-17 17:38:54 173 [http-nio-6061-exec-23] INFO generateId 27:获取到的分布式id:2440808830111755
2021-11-17 17:38:54 173 [http-nio-6061-exec-6] INFO generateId 27:获取到的分布式id:2440808830111757
2021-11-17 17:38:54 173 [http-nio-6061-exec-21] INFO generateId 27:获取到的分布式id:2440808830111759
2021-11-17 17:38:54 173 [http-nio-6061-exec-42] INFO generateId 27:获取到的分布式id:2440808830111758
2021-11-17 17:38:54 173 [http-nio-6061-exec-45] INFO generateId 27:获取到的分布式id:2440808830111760
2021-11-17 17:38:54 174 [http-nio-6061-exec-47] INFO generateId 27:获取到的分布式id:2440808834306049
2021-11-17 17:38:54 174 [http-nio-6061-exec-33] INFO generateId 27:获取到的分布式id:2440808834306050
2021-11-17 17:38:54 174 [http-nio-6061-exec-25] INFO generateId 27:获取到的分布式id:2440808834306051
2021-11-17 17:38:54 174 [http-nio-6061-exec-5] INFO generateId 27:获取到的分布式id:2440808834306052
2021-11-17 17:38:54 174 [http-nio-6061-exec-32] INFO generateId 27:获取到的分布式id:2440808834306048
2021-11-17 17:38:54 174 [http-nio-6061-exec-30] INFO generateId 27:获取到的分布式id:2440808834306053
2021-11-17 17:38:54 174 [http-nio-6061-exec-14] INFO generateId 27:获取到的分布式id:2440808834306054

端口为6062实例的结果：

2021-11-17 17:38:54 195 [http-nio-6062-exec-50] INFO generateId 27:获取到的分布式id:2440808922390531
2021-11-17 17:38:54 195 [http-nio-6062-exec-40] INFO generateId 27:获取到的分布式id:2440808922390533
2021-11-17 17:38:54 196 [http-nio-6062-exec-45] INFO generateId 27:获取到的分布式id:2440808926584834
2021-11-17 17:38:54 196 [http-nio-6062-exec-34] INFO generateId 27:获取到的分布式id:2440808926584835
2021-11-17 17:38:54 195 [http-nio-6062-exec-8] INFO generateId 27:获取到的分布式id:2440808922390529
2021-11-17 17:38:54 196 [http-nio-6062-exec-37] INFO generateId 27:获取到的分布式id:2440808926584832
2021-11-17 17:38:54 195 [http-nio-6062-exec-21] INFO generateId 27:获取到的分布式id:2440808922390530
2021-11-17 17:38:54 195 [http-nio-6062-exec-41] INFO generateId 27:获取到的分布式id:2440808922390532
2021-11-17 17:38:54 195 [http-nio-6062-exec-18] INFO generateId 27:获取到的分布式id:2440808922390528
2021-11-17 17:38:54 196 [http-nio-6062-exec-5] INFO generateId 27:获取到的分布式id:2440808926584836
2021-11-17 17:38:54 196 [http-nio-6062-exec-35] INFO generateId 27:获取到的分布式id:2440808926584837
2021-11-17 17:38:54 196 [http-nio-6062-exec-12] INFO generateId 27:获取到的分布式id:2440808926584838
2021-11-17 17:38:54 196 [http-nio-6062-exec-39] INFO generateId 27:获取到的分布式id:2440808926584840
2021-11-17 17:38:54 196 [http-nio-6062-exec-22] INFO generateId 27:获取到的分布式id:2440808926584839
2021-11-17 17:38:54 196 [http-nio-6062-exec-14] INFO generateId 27:获取到的分布式id:2440808926584833
2021-11-17 17:38:54 199 [http-nio-6062-exec-6] INFO generateId 27:获取到的分布式id:2440808939167744
2021-11-17 17:38:54 197 [http-nio-6062-exec-17] INFO generateId 27:获取到的分布式id:2440808930779136
2021-11-17 17:38:54 199 [http-nio-6062-exec-25] INFO generateId 27:获取到的分布式id:2440808939167745
2021-11-17 17:38:54 199 [http-nio-6062-exec-24] INFO generateId 27:获取到的分布式id:2440808939167746
2021-11-17 17:38:54 200 [http-nio-6062-exec-4] INFO generateId 27:获取到的分布式id:2440808943362048
2021-11-17 17:38:54 200 [http-nio-6062-exec-3] INFO generateId 27:获取到的分布式id:2440808943362050
2021-11-17 17:38:54 200 [http-nio-6062-exec-23] INFO generateId 27:获取到的分布式id:2440808943362049
2021-11-17 17:38:54 200 [http-nio-6062-exec-9] INFO generateId 27:获取到的分布式id:2440808943362051
2021-11-17 17:38:54 200 [http-nio-6062-exec-48] INFO generateId 27:获取到的分布式id:2440808943362052
2021-11-17 17:38:54 200 [http-nio-6062-exec-29] INFO generateId 27:获取到的分布式id:2440808943362054
2021-11-17 17:38:54 200 [http-nio-6062-exec-16] INFO generateId 27:获取到的分布式id:2440808943362055
2021-11-17 17:38:54 201 [http-nio-6062-exec-1] INFO generateId 27:获取到的分布式id:2440808947556352
2021-11-17 17:38:54 200 [http-nio-6062-exec-20] INFO generateId 27:获取到的分布式id:2440808943362056
2021-11-17 17:38:54 200 [http-nio-6062-exec-28] INFO generateId 27:获取到的分布式id:2440808943362053
2021-11-17 17:38:54 201 [http-nio-6062-exec-30] INFO generateId 27:获取到的分布式id:2440808947556353
2021-11-17 17:38:54 201 [http-nio-6062-exec-31] INFO generateId 27:获取到的分布式id:2440808947556354
2021-11-17 17:38:54 201 [http-nio-6062-exec-27] INFO generateId 27:获取到的分布式id:2440808947556355
2021-11-17 17:38:54 201 [http-nio-6062-exec-46] INFO generateId 27:获取到的分布式id:2440808947556356
2021-11-17 17:38:54 201 [http-nio-6062-exec-44] INFO generateId 27:获取到的分布式id:2440808947556357
2021-11-17 17:38:54 201 [http-nio-6062-exec-33] INFO generateId 27:获取到的分布式id:2440808947556358
2021-11-17 17:38:54 201 [http-nio-6062-exec-36] INFO generateId 27:获取到的分布式id:2440808947556359
2021-11-17 17:38:54 201 [http-nio-6062-exec-26] INFO generateId 27:获取到的分布式id:2440808947556361
2021-11-17 17:38:54 201 [http-nio-6062-exec-43] INFO generateId 27:获取到的分布式id:2440808947556362
2021-11-17 17:38:54 201 [http-nio-6062-exec-32] INFO generateId 27:获取到的分布式id:2440808947556360
2021-11-17 17:38:54 202 [http-nio-6062-exec-7] INFO generateId 27:获取到的分布式id:2440808951750656
2021-11-17 17:38:54 202 [http-nio-6062-exec-19] INFO generateId 27:获取到的分布式id:2440808951750657
2021-11-17 17:38:54 202 [http-nio-6062-exec-38] INFO generateId 27:获取到的分布式id:2440808951750658
2021-11-17 17:38:54 202 [http-nio-6062-exec-13] INFO generateId 27:获取到的分布式id:2440808951750659
2021-11-17 17:38:54 203 [http-nio-6062-exec-42] INFO generateId 27:获取到的分布式id:2440808955944960
2021-11-17 17:38:54 203 [http-nio-6062-exec-49] INFO generateId 27:获取到的分布式id:2440808955944961
2021-11-17 17:38:54 203 [http-nio-6062-exec-2] INFO generateId 27:获取到的分布式id:2440808955944962
2021-11-17 17:38:54 204 [http-nio-6062-exec-15] INFO generateId 27:获取到的分布式id:2440808960139264
2021-11-17 17:38:54 205 [http-nio-6062-exec-10] INFO generateId 27:获取到的分布式id:2440808964333568
2021-11-17 17:38:54 205 [http-nio-6062-exec-47] INFO generateId 27:获取到的分布式id:2440808964333569
2021-11-17 17:38:54 205 [http-nio-6062-exec-11] INFO generateId 27:获取到的分布式id:2440808964333570

端口为6063实例的结果：

2021-11-17 17:38:54 167 [http-nio-6063-exec-17] INFO generateId 27:获取到的分布式id:2440808804954129
2021-11-17 17:38:54 167 [http-nio-6063-exec-5] INFO generateId 27:获取到的分布式id:2440808804954120
2021-11-17 17:38:54 168 [http-nio-6063-exec-33] INFO generateId 27:获取到的分布式id:2440808809148416
2021-11-17 17:38:54 168 [http-nio-6063-exec-25] INFO generateId 27:获取到的分布式id:2440808809148422
2021-11-17 17:38:54 167 [http-nio-6063-exec-46] INFO generateId 27:获取到的分布式id:2440808804954124
2021-11-17 17:38:54 167 [http-nio-6063-exec-30] INFO generateId 27:获取到的分布式id:2440808804954116
2021-11-17 17:38:54 168 [http-nio-6063-exec-48] INFO generateId 27:获取到的分布式id:2440808809148423
2021-11-17 17:38:54 168 [http-nio-6063-exec-8] INFO generateId 27:获取到的分布式id:2440808809148425
2021-11-17 17:38:54 167 [http-nio-6063-exec-38] INFO generateId 27:获取到的分布式id:2440808804954126
2021-11-17 17:38:54 168 [http-nio-6063-exec-44] INFO generateId 27:获取到的分布式id:2440808809148427
2021-11-17 17:38:54 168 [http-nio-6063-exec-29] INFO generateId 27:获取到的分布式id:2440808809148428
2021-11-17 17:38:54 167 [http-nio-6063-exec-47] INFO generateId 27:获取到的分布式id:2440808804954118
2021-11-17 17:38:54 168 [http-nio-6063-exec-11] INFO generateId 27:获取到的分布式id:2440808809148430
2021-11-17 17:38:54 167 [http-nio-6063-exec-32] INFO generateId 27:获取到的分布式id:2440808804954123
2021-11-17 17:38:54 167 [http-nio-6063-exec-20] INFO generateId 27:获取到的分布式id:2440808804954130
2021-11-17 17:38:54 168 [http-nio-6063-exec-13] INFO generateId 27:获取到的分布式id:2440808809148420
2021-11-17 17:38:54 168 [http-nio-6063-exec-45] INFO generateId 27:获取到的分布式id:2440808809148418
2021-11-17 17:38:54 167 [http-nio-6063-exec-39] INFO generateId 27:获取到的分布式id:2440808804954122
2021-11-17 17:38:54 167 [http-nio-6063-exec-35] INFO generateId 27:获取到的分布式id:2440808804954115
2021-11-17 17:38:54 168 [http-nio-6063-exec-9] INFO generateId 27:获取到的分布式id:2440808809148421
2021-11-17 17:38:54 167 [http-nio-6063-exec-16] INFO generateId 27:获取到的分布式id:2440808804954125
2021-11-17 17:38:54 167 [http-nio-6063-exec-34] INFO generateId 27:获取到的分布式id:2440808804954127
2021-11-17 17:38:54 169 [http-nio-6063-exec-10] INFO generateId 27:获取到的分布式id:2440808813342721
2021-11-17 17:38:54 167 [http-nio-6063-exec-36] INFO generateId 27:获取到的分布式id:2440808804954114
2021-11-17 17:38:54 167 [http-nio-6063-exec-28] INFO generateId 27:获取到的分布式id:2440808804954121
2021-11-17 17:38:54 167 [http-nio-6063-exec-4] INFO generateId 27:获取到的分布式id:2440808804954117
2021-11-17 17:38:54 167 [http-nio-6063-exec-24] INFO generateId 27:获取到的分布式id:2440808804954128
2021-11-17 17:38:54 167 [http-nio-6063-exec-41] INFO generateId 27:获取到的分布式id:2440808804954119
2021-11-17 17:38:54 167 [http-nio-6063-exec-22] INFO generateId 27:获取到的分布式id:2440808804954113
2021-11-17 17:38:54 169 [http-nio-6063-exec-40] INFO generateId 27:获取到的分布式id:2440808813342720
2021-11-17 17:38:54 168 [http-nio-6063-exec-19] INFO generateId 27:获取到的分布式id:2440808809148429
2021-11-17 17:38:54 169 [http-nio-6063-exec-43] INFO generateId 27:获取到的分布式id:2440808813342723
2021-11-17 17:38:54 170 [http-nio-6063-exec-12] INFO generateId 27:获取到的分布式id:2440808817537025
2021-11-17 17:38:54 170 [http-nio-6063-exec-6] INFO generateId 27:获取到的分布式id:2440808817537026
2021-11-17 17:38:54 169 [http-nio-6063-exec-15] INFO generateId 27:获取到的分布式id:2440808813342722
2021-11-17 17:38:54 168 [http-nio-6063-exec-26] INFO generateId 27:获取到的分布式id:2440808809148426
2021-11-17 17:38:54 170 [http-nio-6063-exec-2] INFO generateId 27:获取到的分布式id:2440808817537024
2021-11-17 17:38:54 170 [http-nio-6063-exec-50] INFO generateId 27:获取到的分布式id:2440808817537027
2021-11-17 17:38:54 167 [http-nio-6063-exec-23] INFO generateId 27:获取到的分布式id:2440808804954112
2021-11-17 17:38:54 170 [http-nio-6063-exec-27] INFO generateId 27:获取到的分布式id:2440808817537028
2021-11-17 17:38:54 168 [http-nio-6063-exec-1] INFO generateId 27:获取到的分布式id:2440808809148424
2021-11-17 17:38:54 168 [http-nio-6063-exec-18] INFO generateId 27:获取到的分布式id:2440808809148419
2021-11-17 17:38:54 168 [http-nio-6063-exec-37] INFO generateId 27:获取到的分布式id:2440808809148417
2021-11-17 17:38:54 170 [http-nio-6063-exec-21] INFO generateId 27:获取到的分布式id:2440808817537029
2021-11-17 17:38:54 171 [http-nio-6063-exec-7] INFO generateId 27:获取到的分布式id:2440808821731328
2021-11-17 17:38:54 171 [http-nio-6063-exec-42] INFO generateId 27:获取到的分布式id:2440808821731329
2021-11-17 17:38:54 171 [http-nio-6063-exec-14] INFO generateId 27:获取到的分布式id:2440808821731330
2021-11-17 17:38:54 171 [http-nio-6063-exec-3] INFO generateId 27:获取到的分布式id:2440808821731331
2021-11-17 17:38:54 171 [http-nio-6063-exec-49] INFO generateId 27:获取到的分布式id:2440808821731332
2021-11-17 17:38:54 171 [http-nio-6063-exec-31] INFO generateId 27:获取到的分布式id:2440808821731333

六、Snowflake优缺点 6.1、优点

ID在内存生成，不依赖于数据库，高性能高可用。
每秒可生成几百万ID，容量大
由于ID呈趋势递增，插入数据库后，使用索引的时候性能较高。

6.2、缺点

依赖于系统时钟的一致性，如果某台机器的系统时钟回拨，有可能造成ID冲突或者ID乱序。
同一台机器的系统时间回拨过，那么有可能出现ID重复的情况

结语

其实在这里大家也看到了我们在使用snowflake的一个局限性，一个是数据中心只有32，机器位也只有32，当然大家可以扩展，实际上机器位32对于绝大大部分公司来说足够了，只是数据中心可能会不够，那么就向时间戳那里借几位，比如你借两位就可以支持128了，当然相应的时间戳可用时间也缩短成（ (1L << 39) / (1000L * 60 * 60 * 24 * 365)=17年），大家根据需求自行选择。
还有一个就是实际使用这个workerId时其实不是很好维护，当然如果有用到数据库或者redis那维护就更容易了，为了不把本文搞复杂，本文就这么写，大家就参考下实现的思路吧，不管怎么样，本服务不管是单台机器部署多个，还是不同机器部署多个都不会有问题，包括单机，分布式，容器环境，当然有兴趣的小伙伴可以使用美团的 leaf-Snowflake。

Spring Boot基于Zookeeper和Snowflake生成唯一ID完整版

大数据系统相关栏目本月热门文章