分库分表下的 ID 冲突问题与雪花算法讲解

-- 分库前：单库自增ID保证唯一性
INSERT INTO orders(id, user_id) VALUES(NULL, 1001); -- 自动生成ID=1

-- 分库后：库1和库2各自生成ID=1
库1: INSERT INTO orders(id, user_id) VALUES(NULL, 1001); -- ID=1
库2: INSERT INTO orders(id, user_id) VALUES(NULL, 1002); -- ID=1（冲突）

-- 库1：从1开始，步长2（生成1,3,5...）
SET @@auto_increment_offset = 1; 
SET @@auto_increment_increment = 2;

-- 库2：从2开始，步长2（生成2,4,6...）
SET @@auto_increment_offset = 2; 
SET @@auto_increment_increment = 2;

String uuid = UUID.randomUUID().toString();

// 获取下一个订单ID
Long orderId = redisTemplate.opsForValue().increment("order_id_generator", 1);

1位符号位 | 41位时间戳 | 5位数据中心ID | 5位机器ID | 12位序列号  

1位符号位 | 41位时间戳 | 5位数据中心ID | 5位机器ID | 12位序列号  

public class SnowflakeIdGenerator {
    // 起始时间戳（2021-01-01 00:00:00）
    private final long startTimestamp = 1609459200000L;
    
    // 各部分位数
    private final long dataCenterIdBits = 5L;  // 数据中心ID位数
    private final long workerIdBits = 5L;       // 机器ID位数
    private final long sequenceBits = 12L;     // 序列号位数
    
    // 最大取值计算
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);  // 31
    private final long maxDataCenterId = -1L ^ (-1L << dataCenterIdBits);  // 31
    private final long maxSequence = -1L ^ (-1L << sequenceBits);  // 4095
    
    // 位移偏移量
    private final long workerIdShift = sequenceBits;
    private final long dataCenterIdShift = sequenceBits + workerIdBits;
    private final long timestampShift = sequenceBits + workerIdBits + dataCenterIdBits;
    
    // 实例变量
    private long dataCenterId;  // 数据中心ID
    private long workerId;      // 机器ID
    private long sequence = 0L; // 序列号
    private long lastTimestamp = -1L; // 上次生成ID的时间戳
    
    // 构造函数（参数需提前规划分配）
    public SnowflakeIdGenerator(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.dataCenterId = dataCenterId;
        this.workerId = workerId;
    }
    
    // 同步生成ID（避免并发冲突）
    public synchronized long nextId() {
        long timestamp = currentTimeMillis();
        
        // 时钟回拨处理（核心坑点）
        if (timestamp < lastTimestamp) {
            long offset = lastTimestamp - timestamp;
            if (offset <= 5) {
                // 短时间回拨：等待至lastTimestamp后再生成
                try {
                    wait(offset);
                    timestamp = currentTimeMillis();
                    if (timestamp < lastTimestamp) {
                        throw new RuntimeException("Clock moved backwards. Refusing to generate id.");
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            } else {
                // 长时间回拨：直接抛异常（需人工处理）
                throw new RuntimeException(
                    String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", offset));
            }
        }
        
        // 同一毫秒内
        if (timestamp == lastTimestamp) {
            // 序列号自增，达到上限则等待下一毫秒
            sequence = (sequence + 1) & maxSequence;
            if (sequence == 0) {
                timestamp = waitNextMillis(lastTimestamp);
            }
        } else {
            // 新毫秒，序列号重置为0
            sequence = 0L;
        }
        
        lastTimestamp = timestamp;
        
        // 组合各部分生成ID
        return ((timestamp - startTimestamp) << timestampShift) |
               (dataCenterId << dataCenterIdShift) |
               (workerId << workerIdShift) |
               sequence;
    }
    
    // 获取当前时间戳
    private long currentTimeMillis() {
        return System.currentTimeMillis();
    }
    
    // 等待至下一毫秒
    private long waitNextMillis(long lastTimestamp) {
        long timestamp = currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = currentTimeMillis();
        }
        return timestamp;
    }
}