分布式唯一ID

package cn.itcast.Demo21.algorithm;
// 雪花算法生成的id采用long整型存储，即64位=12位序列号+10位机器标志号+41位时间戳+1位符号位
public class SnowFlake {
    // 采用时间戳占用位数
    private final static long START_STAMP = 1645581043000L;
    // 序列号占用的位数
    private final static long SEQUENCE_BIT = 12;
    // 机器标识占用的位数
    private final static long MACHINE_BIT = 5;
    // 数据中心占用的位数
    private final static long DATA_CENTER_BIT = 5;

    // 每个部分的最大值
    private final static long MAX_DATA_CENTER_NUM = ~(-1L << DATA_CENTER_BIT);
    private final static long MAX_MACHINE_NUM = ~(-1L << MACHINE_BIT);
    private final static long MAX_SEQUENCE = ~(-1L << SEQUENCE_BIT);

    // 每一部分向左的位移
    private final static long MACHINE_LEFT = SEQUENCE_BIT;
    private final static long DATA_CENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
    private final static long TIMESTAMP_LEFT = DATA_CENTER_LEFT + DATA_CENTER_BIT;

    // 毫秒内序列（0~4095）
    private long sequence = 0L;
    // 数据中心ID(0-31)
    private final long dataCenterId;
    // 工作机器ID(0-31)
    private final long machineId;
    // 上次生成ID的时间戳
    private long lastStamp = -1L;

    // 构造器
    public SnowFlake(long dataCenterId, long machineId){
        if (dataCenterId>MAX_DATA_CENTER_NUM || dataCenterId<0){
            throw new IllegalArgumentException("传入的数据中心序列号超出范围");
        }
        if (machineId>MAX_MACHINE_NUM||machineId<0){
            throw new IllegalArgumentException("传入的机器序列号超出范围");
        }
        this.dataCenterId = dataCenterId;
        this.machineId = machineId;
    }
    // 获取当前时间戳
    private long getNewStamp(){
        return System.currentTimeMillis();
    }
    private long getNextMill(){
        long mill = getNewStamp();
        while(mill <= lastStamp){
            mill = getNewStamp();
        }
        return mill;
    }
    // 产生下一个ID
    public synchronized long nextId(){
        long currStamp = getNewStamp();
        if (currStamp < lastStamp){
            throw new RuntimeException("系统时间不准确，拒绝生成ID");
        }
        if (currStamp == lastStamp){
            // 相同毫秒内，序列号自增
            sequence = (sequence + 1) & MAX_SEQUENCE;
            // 同一毫秒内的序列数已经达到了最大
            if (sequence == 0L){
                // 阻塞到下一个毫秒，获得新的时间戳
                currStamp = getNextMill();
            }
        }else {
            // 不同毫秒内，序列号置为0
            sequence = 0L;
        }
        lastStamp = currStamp;
        // 移位并通过或运算拼到一起组成64位的ID
        return (currStamp - START_STAMP) << TIMESTAMP_LEFT // 时间戳部分
        | dataCenterId << DATA_CENTER_LEFT                 // 数据中心部分
        | machineId << MACHINE_LEFT                        // 机器标识部分
        | sequence;                                        // 序列号部分
    }
    public static void main(String[] args) {
        SnowFlake snowFlake = new SnowFlake(11, 11);

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            System.out.println(snowFlake.nextId());
        }

        System.out.println(System.currentTimeMillis() - start);
    }
}