雪花算法生成20位long id

你好，你可以使用以下Java代码来生成20位long id：

public static long generateId() {
    // 生成6位随机数
    String random = String.valueOf((long) ((Math.random() * 9 + 1) * 100000));

    // 获取当前时间戳
    String timestamp = String.valueOf(System.currentTimeMillis());

    // 拼接生成ID字符串
    String idStr = timestamp + random;

    // 转成long类型
    return Long.parseLong(idStr);
}

这个方法通过在当前时间戳后面拼接6位随机数来生成20位long id。每次调用这个方法都会生成一个不重复的id。

相关问题

java雪花算法生成18位id

雪花算法是一种生成全局唯一ID的算法，常用于分布式系统中。这种算法的实现基于时间戳、机器ID和序列号，以保证生成的ID在分布式环境下的唯一性。

要生成一个18位的雪花算法ID，可以按照以下步骤进行：

1. 定义一个起始时间戳，例如可以取当前时间的起始时间戳（如2022年1月1日），将其转换为毫秒级的时间戳。
2. 定义一个机器ID，可以根据实际情况分配一个唯一的机器ID，通常可以使用服务器的IP地址或其他唯一标识符。
3. 定义一个序列号，表示同一毫秒内生成的ID的序号，从0开始递增。
4. 在生成ID时，先获取当前时间戳的毫秒级表示。
5. 将时间戳左移5位，腾出5位给机器ID使用。
6. 将机器ID左移13位，腾出5位给序列号使用。
7. 将当前时间戳、机器ID和序列号进行按位或操作，得到最终的ID值。
8. 将ID转换为字符串，并补齐到18位长度。

需要注意的是，18位的ID长度可能会超过Java的long类型的表示范围，因此可以考虑使用字符串来表示ID。

请注意，这只是一种示例的实现方式，你可以根据自己的需求进行调整和改进。

java 雪花算法生成9位id

雪花算法是一种分布式唯一 ID 生成算法，可以生成唯一的、有序的、可排序的、高并发的 ID。以下是 Java 实现的 9 位雪花算法生成 ID 的示例代码：

public class SnowflakeIdGenerator {
    private static final long START_STAMP = 1577808000000L; // 2020-01-01 00:00:00
    private static final long SEQUENCE_BITS = 4L;
    private static final long WORKER_ID_BITS = 5L;
    private static final long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS);
    private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
    private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;
    private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;

    private volatile long lastTimestamp = -1L;
    private volatile long sequence = 0L;
    private final long workerId;

    public SnowflakeIdGenerator(long workerId) {
        if (workerId > MAX_WORKER_ID || workerId < 0) {
            throw new IllegalArgumentException("Worker ID must be between 0 and " + MAX_WORKER_ID);
        }
        this.workerId = workerId;
    }

    public synchronized long nextId() {
        long currentTimestamp = System.currentTimeMillis();
        if (currentTimestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards! Refusing to generate ID");
        }
        if (currentTimestamp == lastTimestamp) {
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0) {
                currentTimestamp = nextTimestamp(currentTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = currentTimestamp;
        return ((currentTimestamp - START_STAMP) << TIMESTAMP_SHIFT) |
                (workerId << WORKER_ID_SHIFT) |
                sequence;
    }

    private long nextTimestamp(long currentTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= currentTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

此代码中，我们使用一个 long 类型的变量来表示生成的 ID，其中，前 41 位是时间戳（毫秒级），接着的 5 位是机器 ID，最后的 4 位是序列号。根据雪花算法的规则，序列号是每毫秒内的计数器，最大值为 15，超过则等待下一毫秒再生成 ID。

使用此类生成 9 位 ID，我们可以将机器 ID 的位数减少为 4，序列号的位数减少为 1，时间戳的起点可以设为 2020-01-01 00:00:00，代码如下：

public class NineDigitsSnowflakeIdGenerator {
    private static final long START_STAMP = 1577808000000L; // 2020-01-01 00:00:00
    private static final long SEQUENCE_BITS = 1L;
    private static final long WORKER_ID_BITS = 4L;
    private static final long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS);
    private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
    private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;
    private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;

    private volatile long lastTimestamp = -1L;
    private volatile long sequence = 0L;
    private final long workerId;

    public NineDigitsSnowflakeIdGenerator(long workerId) {
        if (workerId > MAX_WORKER_ID || workerId < 0) {
            throw new IllegalArgumentException("Worker ID must be between 0 and " + MAX_WORKER_ID);
        }
        this.workerId = workerId;
    }

    public synchronized long nextId() {
        long currentTimestamp = System.currentTimeMillis();
        if (currentTimestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards! Refusing to generate ID");
        }
        if (currentTimestamp == lastTimestamp) {
            sequence = (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0) {
                currentTimestamp = nextTimestamp(currentTimestamp);
            }
        } else {
            sequence = 0L;
        }
        lastTimestamp = currentTimestamp;
        return ((currentTimestamp - START_STAMP) << TIMESTAMP_SHIFT) |
                (workerId << WORKER_ID_SHIFT) |
                sequence;
    }

    private long nextTimestamp(long currentTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= currentTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}