雪中飞舞的花：雪花算法优化方案

后端

2023-02-22 12:05:20

改造后的雪花算法：缩短 ID 长度，减轻前端负担

雪花算法：分布式 ID 生成利器

雪花算法是一种分布式 ID 生成算法，能够有效解决自增 ID 的并发问题。它将 ID 细分为多个部分，代表不同的信息，如时间戳、工作节点 ID 和序列号。通过这种方式，雪花算法保证了 ID 的唯一性，并支持多个工作节点并行生成 ID。

雪花算法的痛点：ID 长度过长

尽管雪花算法优势明显，但它也存在一个缺点：生成的 ID 长度较长，通常为 19 位。这会给前端带来一定影响。例如，在 JavaScript 中，需要将 ID 转换为字符串类型，这可能会降低性能。

改造雪花算法：缩短 ID 长度

为了解决 ID 长度过长的缺陷，我们可以对雪花算法进行改造，缩短 ID 长度为 16 位或 15 位。这种改造不会影响雪花算法的唯一性和并发性，却能大大减轻前端的负担。

改造后的雪花算法 ID 长度

改造后的雪花算法 ID 长度可选择为 16 位或 15 位。并发量较小的情况，可以使用 15 位 ID 长度；并发量较大的场景，可以使用 16 位 ID 长度。

改造后的雪花算法实现

改造后的雪花算法实现十分简洁，只需在原有雪花算法的基础上缩短 ID 长度即可。以下提供一个 Java 实现示例：

public class ModifiedSnowflakeIdWorker {

    private static final long EPOCH = 1420041600000L; // 起始时间戳
    private static final long WORKER_ID_BITS = 10L; // 工作节点 ID 长度
    private static final long DATACENTER_ID_BITS = 5L; // 数据中心 ID 长度
    private static final long SEQUENCE_BITS = 12L; // 序列号长度
    private static final long WORKER_ID_SHIFT = SEQUENCE_BITS; // 工作节点 ID 左移位数
    private static final long DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS; // 数据中心 ID 左移位数
    private static final long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS; // 时间戳左移位数
    private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS); // 序列号掩码

    private long workerId; // 工作节点 ID
    private long datacenterId; // 数据中心 ID
    private long sequence; // 序列号
    private long lastTimestamp; // 上一次时间戳

    public ModifiedSnowflakeIdWorker(long workerId, long datacenterId) {
        this.workerId = workerId;
        this.datacenterId = datacenterId;
        this.sequence = 0L;
        this.lastTimestamp = -1L;
    }

    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards. Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
        }
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & SEQUENCE_MASK;
            if (sequence == 0L) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        long id = ((timestamp - EPOCH) << TIMESTAMP_LEFT_SHIFT) |
                (datacenterId << DATACENTER_ID_SHIFT) |
                (workerId << WORKER_ID_SHIFT) |
                sequence;

        return id;
    }

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

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