/**
 * 雪花Id生成器
 *
 * @author zhuyu
 * @date 2022/4/6 10:32 下午
 */
public class SnowflakeIdGenerator {

    /**
     * 单例
     */
    public static SnowflakeIdGenerator instance = new SnowflakeIdGenerator();

    /**
     * 初始化单例
     * @Param workerId 最大值8192
     */
    public synchronized void init(long workerId) {
        if (workerId > MAX_WORKER_ID) {
            //ZK分配的workerId过大
            throw new IllegalArgumentException("woker Id wrong: " + workerId);
        }
        instance.workerId = workerId;
    }

    private SnowflakeIdGenerator() {
    }

    public static void main(String[] args) {
        //new SnowflakeIdTest().snowflakeIdTest();

        //初始化id生成器
        SnowflakeIdGenerator.instance.init(1);
        System.out.println(" ID001：" + SnowflakeIdGenerator.instance.nextId());
        System.out.println(" ID001：" + SnowflakeIdGenerator.instance.nextId());

        SnowflakeIdGenerator.instance.init(100);
        System.out.println(" ID100：" + SnowflakeIdGenerator.instance.nextId());
        System.out.println(" ID100：" + SnowflakeIdGenerator.instance.nextId());

        SnowflakeIdGenerator.instance.init(300);
        System.out.println(" ID300：" + SnowflakeIdGenerator.instance.nextId());
        System.out.println(" ID300：" + SnowflakeIdGenerator.instance.nextId());

        SnowflakeIdGenerator.instance.init(2145);
        System.out.println(" ID2145：" + SnowflakeIdGenerator.instance.nextId());
        System.out.println(" ID2145：" + SnowflakeIdGenerator.instance.nextId());

        SnowflakeIdGenerator.instance.init(7634);
        System.out.println(" ID7634：" + SnowflakeIdGenerator.instance.nextId());
        System.out.println(" ID7634：" + SnowflakeIdGenerator.instance.nextId());
        System.out.println(" ID7634 length：" + String.valueOf(SnowflakeIdGenerator.instance.nextId()).length());	
    }

    /**
     * 开始使用该算法的时间为2017-01-01 00:00:00
     */
    private static final long START_TIME = 1483200000000L;

    /**
     * worker id 的位数，最多支持8192个节点
     */
    private static final int WORKER_ID_BITS = 13;

    /**
     * 序列号，支持单节点最高每毫秒的最大ID数1024
     */
    private final static int SEQUENCE_BITS = 10;

    /**
     * 最大的 worker id，8091
     * -1 的补码（二进制全1）右移13位，然后取反
     */
    private final static long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);

    /**
     * 最大的序列号，1023
     * -1 的补码（二进制全1）右移10位, 然后取反
     */
    private final static long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS);

    /**
     * worker 节点编号的移位
     */
    private final static long APP_HOST_ID_SHIFT = SEQUENCE_BITS;

    /**
     * 时间戳的移位
     */
    private final static long TIMESTAMP_LEFT_SHIFT = WORKER_ID_BITS + APP_HOST_ID_SHIFT;

    /**
     * 该项目的worker 节点 id
     */
    private long workerId;

    /**
     * 上次生成ID的时间戳
     */
    private long lastTimestamp = -1L;

    /**
     * 当前毫秒生成的序列
     */
    private long sequence = 0L;

    /**
     * Next id long.
     *
     * @return the nextId
     */
    public Long nextId() {
        return generateId();
    }

    /**
     * 生成唯一ID的具体实现
     */
    private synchronized long generateId() {
        long current = System.currentTimeMillis();

        if (current < lastTimestamp) {
            //如果当前时间小于上一次ID生成的时间戳
            //说明系统时钟回退过，出现问题返回-1，生成ID失败
            return -1;
        }

        if (current == lastTimestamp) {
            //如果当前生成ID的时间还是上次的时间，那么对sequence序列号进行+1
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == MAX_SEQUENCE) {
                //当前毫秒生成的序列数已经大于最大值
                //那么阻塞到下一毫秒再获取新的时间戳
                current = this.nextMs(lastTimestamp);
            }
        } else {
            //当前的时间戳已经是下一毫秒
            sequence = 0L;
        }

        //更新上次生成ID的时间戳
        lastTimestamp = current;

        //进行移位操作生成int64的唯一ID
        //时间戳右移23位
        long time = (current - START_TIME) << TIMESTAMP_LEFT_SHIFT;

        //workerId 右移10位
        long workerId = this.workerId << APP_HOST_ID_SHIFT;

        return time | workerId | sequence; //返回ID
    }

    /**
     * 阻塞到下一毫秒
     */
    private long nextMs(long timeStamp) {
        long current = System.currentTimeMillis();
        while (current <= timeStamp) {
            current = System.currentTimeMillis();
        }
        return current;
    }

}	

首先写一个util工具类

package com.xuehua.util;

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;

/**
 * @Author Chenxinlele
 * @Date 2021/8/11 15:58
 * @Version 1.0
 */
public class SnowflakeId {

    /**
     * id自增器（雪花算法）
     *
     * @author renjie
     * @version 1.0.0
     */
    private final static long twepoch = 12888349746579L;
    // 机器标识位数
    private final static long workerIdBits = 5L;
    // 数据中心标识位数
    private final static long datacenterIdBits = 5L;

    // 毫秒内自增位数
    private final static long sequenceBits = 12L;
    // 机器ID偏左移12位
    private final static long workerIdShift = sequenceBits;
    // 数据中心ID左移17位
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    // 时间毫秒左移22位
    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    //sequence掩码，确保sequnce不会超出上限
    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    //上次时间戳
    private static long lastTimestamp = -1L;
    //序列
    private long sequence = 0L;
    //服务器ID
    private long workerId = 1L;
    private static long workerMask = -1L ^ (-1L << workerIdBits);
    //进程编码
    private long processId = 1L;
    private static long processMask = -1L ^ (-1L << datacenterIdBits);

    private static SnowflakeId snowFlake = null;

    static {
        snowFlake = new SnowflakeId();
    }

    public static synchronized long nextId() {
        return snowFlake.getNextId();
    }

    private SnowflakeId() {

        //获取机器编码
        this.workerId = this.getMachineNum();
        //获取进程编码
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        this.processId = Long.valueOf(runtimeMXBean.getName().split("@")[0]).longValue();

        //避免编码超出最大值
        this.workerId = workerId & workerMask;
        this.processId = processId & processMask;
    }

    public synchronized long getNextId() {
        //获取时间戳
        long timestamp = timeGen();
        //如果时间戳小于上次时间戳则报错
        if (timestamp < lastTimestamp) {
            try {
                throw new Exception("Clock moved backwards.  Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //如果时间戳与上次时间戳相同
        if (lastTimestamp == timestamp) {
            // 当前毫秒内，则+1，与sequenceMask确保sequence不会超出上限
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 当前毫秒内计数满了，则等待下一秒
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0;
        }
        lastTimestamp = timestamp;
        // ID偏移组合生成最终的ID，并返回ID
        long nextId = ((timestamp - twepoch) << timestampLeftShift) | (processId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
        return nextId;
    }

    /**
     * 再次获取时间戳直到获取的时间戳与现有的不同
     *
     * @param lastTimestamp
     * @return 下一个时间戳
     */
    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }

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

    /**
     * 获取机器编码
     *
     * @return
     */
    private long getMachineNum() {
        long machinePiece;
        StringBuilder sb = new StringBuilder();
        Enumeration<NetworkInterface> e = null;
        try {
            e = NetworkInterface.getNetworkInterfaces();
        } catch (SocketException e1) {
            e1.printStackTrace();
        }
        while (e.hasMoreElements()) {
            NetworkInterface ni = e.nextElement();
            sb.append(ni.toString());
        }
        machinePiece = sb.toString().hashCode();
        return machinePiece;
    }
}

直接调用

long xhId =SnowflakeId.nextId();

public class SmallSnowflake {

    public static final int NODE_SHIFT = 10;
    public static final int SEQ_SHIFT  = 12;

    public static final short MAX_NODE     = 1023;
    public static final short MAX_SEQUENCE = 4095;

    private short sequence;
    private long  referenceTime;

    private int node;

   
    public SmallSnowflake(int node) {
        if (node < 0 || node > MAX_NODE) {
            throw new IllegalArgumentException(String.format("node must be between %s and %s", 0, MAX_NODE));
        }
        this.node = node;
    }

    
    public synchronized long next() {
        long currentTime = this.getCurrentTimeMillis();
        long counter;
        if (currentTime < referenceTime) {
            throw new RuntimeException(String.format("Last referenceTime %s is after reference time %s", referenceTime, currentTime));
        } else if (currentTime > referenceTime) {
            this.sequence = 0;
        } else {
            if (this.sequence < SmallSnowflake.MAX_SEQUENCE) {
                this.sequence++;
            } else {
                throw new RuntimeException("Sequence exhausted at " + this.sequence);
            }
        }
        counter = this.sequence;
        referenceTime = currentTime;

        return currentTime << NODE_SHIFT << SEQ_SHIFT | node << SEQ_SHIFT | counter;
    }

    protected long getCurrentTimeMillis() {
        return System.currentTimeMillis() / 1000;
    }


public class LargeSnowflake extends SmallSnowflake {

    public LargeSnowflake(int node) {
        super(node);
    }

    @Override
    protected long getCurrentTimeMillis() {
        return System.currentTimeMillis();
    }
}


   public static void main(String[] args) {
        LargeSnowflake lsf = new LargeSnowflake(1);
        System.out.println(lsf.next());
        SmallSnowflake ssf = new SmallSnowflake(1);
        System.out.println(ssf.next());
    }