雪花ID生成

package com.zfsw.spzx.access.service;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.concurrent.ThreadLocalRandom;

/**

  • Twitter_Snowflake

  • SnowFlake的结构如下(每部分用-分开):

  • 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 -

  • 000000000000

  • 1位标识,由于long基本类型在Java中是带符号的,最高位是符号位,正数是0,负数是1,所以id一般是正数,最高位是0

  • 41位时间截(毫秒级),注意,41位时间截不是存储当前时间的时间截,而是存储时间截的差值(当前时间截 - 开始时间截)

  • 得到的值),这里的的开始时间截,一般是我们的id生成器开始使用的时间,由我们程序来指定的(如下下面程序IdWorker类的startTime属性)。41位的时间截,可以使用69年,年T

  • = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69

  • 10位的数据机器位,可以部署在1024个节点,包括5位datacenterId和5位workerId

  • 12位序列,毫秒内的计数,12位的计数顺序号支持每个节点每毫秒(同一机器,同一时间截)产生4096个ID序号

  • 加起来刚好64位,为一个Long型。

  • SnowFlake的优点是,整体上按照时间自增排序,并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分),并且效率较高,经测试,SnowFlake每秒能够产生26万ID左右。

  • @author
    */
    @Slf4j
    public class SnowflakeIdGenerator {

    // Fields=============
    /**

    • 开始时间截 (2015-01-01)
      */
      // Justin
      // private final long twepoch = 1420041600000L;
      private final long twepoch = 1288834974657L;

    /**

    • 机器id所占的位数
      */
      private final long workerIdBits = 5L;

    /**

    • 数据标识id所占的位数
      */
      private final long datacenterIdBits = 5L;

    /**

    • 支持的最大机器id,结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
      */
      private final long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /**

    • 支持的最大数据标识id,结果是31
      */
      private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

    /**

    • 序列在id中占的位数
      */
      private final long sequenceBits = 12L;

    /**

    • 机器ID向左移12位
      */
      private final long workerIdShift = sequenceBits;

    /**

    • 数据标识id向左移17位(12+5)
      */
      private final long datacenterIdShift = sequenceBits + workerIdBits;

    /**

    • 时间截向左移22位(5+5+12)
      */
      private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    /**

    • 生成序列的掩码,这里为4095 (0b111111111111=0xfff=4095)
      */
      private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    /**

    • 工作机器ID(0~31)
      */
      private long workerId;

    /**

    • 数据中心ID(0~31)
      */
      private long datacenterId;

    /**

    • 毫秒内序列(0~4095)
      */
      private long sequence = 0L;

    /**

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

    // Constructors=======

    // Justin
    public SnowflakeIdGenerator() {
    this.datacenterId = getDatacenterId(maxDatacenterId);
    this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
    }

    /**

    • 构造函数
    • @param workerId 工作ID (0~31)
    • @param datacenterId 数据中心ID (0~31)
      */
      public SnowflakeIdGenerator(long workerId, long datacenterId) {
      if (workerId > maxWorkerId || workerId < 0) {
      throw new IllegalArgumentException(
      String.format(“worker Id can’t be greater than %d or less than 0”, maxWorkerId));
      }
      if (datacenterId > maxDatacenterId || datacenterId < 0) {
      throw new IllegalArgumentException(
      String.format(“datacenter Id can’t be greater than %d or less than 0”, maxDatacenterId));
      }
      this.workerId = workerId;
      this.datacenterId = datacenterId;
      }

    // Methods============

    protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
    StringBuilder mpid = new StringBuilder();
    mpid.append(datacenterId);
    String name = ManagementFactory.getRuntimeMXBean().getName();
    if (StringUtils.isNotBlank(name)) {
    /*
    * GET jvmPid
    /
    mpid.append(name.split(“@”)[0]);
    }
    /

    * MAC + PID 鐨� hashcode 鑾峰彇16涓綆浣�
    */
    return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
    }

    /**

    • 鏁版嵁鏍囪瘑id閮ㄥ垎
      */
      protected static long getDatacenterId(long maxDatacenterId) {
      long id = 0L;
      try {
      InetAddress ip = InetAddress.getLocalHost();
      NetworkInterface network = NetworkInterface.getByInetAddress(ip);
      if (network == null) {
      id = 1L;
      } else {
      byte[] mac = network.getHardwareAddress();
      if (null != mac) {
      id = ((0x000000FF & (long) mac[mac.length - 1])
      | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
      id = id % (maxDatacenterId + 1);
      }
      }
      } catch (Exception e) {
      log.warn(" getDatacenterId: " + e.getMessage());
      }
      return id;
      }

    /**

    • 获得下一个ID (该方法是线程安全的)

    • @return SnowflakeId
      */
      public synchronized long nextId() {
      long timestamp = timeGen();

      // 如果当前时间小于上一次ID生成的时间戳,说明系统时钟回退过这个时候应当抛出异常
      if (timestamp < lastTimestamp) {
      // Justin
      // throw new RuntimeException(
      // String.format(“Clock moved backwards. Refusing to generate autoconfigure for %d milliseconds”, lastTimestamp - timestamp));
      long offset = lastTimestamp - timestamp;
      if (offset <= 5) {
      try {
      wait(offset << 1);
      timestamp = timeGen();
      if (timestamp < lastTimestamp) {
      throw new RuntimeException(String
      .format(“Clock moved backwards. Refusing to generate id for %d milliseconds”, offset));
      }
      } catch (Exception e) {
      throw new RuntimeException(e);
      }
      } else {
      throw new RuntimeException(
      String.format(“Clock moved backwards. Refusing to generate id for %d milliseconds”, offset));
      }
      }

      // 如果是同一时间生成的,则进行毫秒内序列
      if (lastTimestamp == timestamp) {
      sequence = (sequence + 1) & sequenceMask;
      // 毫秒内序列溢出
      if (sequence == 0) {
      // 阻塞到下一个毫秒,获得新的时间戳
      timestamp = tilNextMillis(lastTimestamp);
      }
      }
      // 时间戳改变,毫秒内序列重置
      else {
      // sequence = 0L; // Justin
      sequence = ThreadLocalRandom.current().nextLong(1, 3);
      }

      // 上次生成ID的时间截
      lastTimestamp = timestamp;

      // 移位并通过或运算拼到一起组成64位的ID
      return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift)
      | (workerId << workerIdShift) | sequence;
      }

    /**

    • 阻塞到下一个毫秒,直到获得新的时间戳
    • @param lastTimestamp 上次生成ID的时间截
    • @return 当前时间戳
      */
      protected long tilNextMillis(long lastTimestamp) {
      long timestamp = timeGen();
      while (timestamp <= lastTimestamp) {
      timestamp = timeGen();
      }
      return timestamp;
      }

    /**

    • 返回以毫秒为单位的当前时间
    • @return 当前时间(毫秒)
      */
      protected long timeGen() {
      return System.currentTimeMillis();
      }

    // Test===============

    public static void main(String[] args) {
    SnowflakeIdGenerator snowflakeIdGenerator = new SnowflakeIdGenerator(0, 0);
    System.out.println(String.valueOf(snowflakeIdGenerator.nextId()));
    System.out.println(String.valueOf(snowflakeIdGenerator.nextId()));
    }
    }

总结一下,除了此方法之外,还可以用hutool工具中的雪花id,已经集成了。
引用自:https://blog.csdn.net/qq_40083897/article/details/121083136

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的雪花ID生成算法是一种分布式唯一ID生成算法,它使用了时间戳、机器ID和序列号来生成全局唯一的ID。 具体实现过程如下: 1. 定义一个64位的long类型变量,其中第一位是符号位(始终为0),接下来41位是时间戳,5位是数据中心ID,5位是机器ID,最后12位是序列号。 2. 时间戳部分采用当前时间减去一个固定的起始时间,可以保证生成ID是递增的。 3. 数据中心ID和机器ID可以预先分配,这样可以保证同一数据中心内的机器ID不会重复。 4. 序列号部分可以使用一个计数器来实现,每次生成ID时将计数器加一即可,需要注意的是,如果在同一毫秒内生成ID数量超过了4096(2^12),则需要等待一毫秒,以保证生成ID不重复。 示例代码如下: ```java public class SnowflakeIdWorker { // 起始的时间戳 private final static long START_TIMESTAMP = 1480166465631L; // 机器id所占的位数 private final static long WORKER_ID_BITS = 5L; // 数据标识id所占的位数 private final static long DATA_CENTER_ID_BITS = 5L; // 支持的最大机器id,结果是31 private final static long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS); // 支持的最大数据标识id,结果是31 private final static long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS); // 序列在id中占的位数 private final static long SEQUENCE_BITS = 12L; // 机器ID向左移12位 private final static long WORKER_ID_SHIFT = SEQUENCE_BITS; // 数据标识id向左移17位(12+5) private final static long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS; // 时间截向左移22位(5+5+12) private final static long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS; // 生成序列的掩码,这里为4095(0b111111111111=0xfff=4095) private final static long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS); // 工作机器ID(0~31) private long workerId; // 数据中心ID(0~31) private long dataCenterId; // 毫秒内序列(0~4095) private long sequence = 0L; // 上次生成ID的时间戳 private long lastTimestamp = -1L; public SnowflakeIdWorker(long workerId, long dataCenterId) { if (workerId > MAX_WORKER_ID || workerId < 0) { throw new IllegalArgumentException("workerId can't be greater than " + MAX_WORKER_ID + " or less than 0"); } if (dataCenterId > MAX_DATA_CENTER_ID || dataCenterId < 0) { throw new IllegalArgumentException("dataCenterId can't be greater than " + MAX_DATA_CENTER_ID + " or less than 0"); } this.workerId = workerId; this.dataCenterId = dataCenterId; } public synchronized long nextId() { long timestamp = timeGen(); if (timestamp < lastTimestamp) { throw new RuntimeException("Clock moved backwards. Refusing to generate id"); } if (lastTimestamp == timestamp) { sequence = (sequence + 1) & SEQUENCE_MASK; if (sequence == 0) { timestamp = tilNextMillis(lastTimestamp); } } else { sequence = 0L; } lastTimestamp = timestamp; return ((timestamp - START_TIMESTAMP) << TIMESTAMP_LEFT_SHIFT) | (dataCenterId << DATA_CENTER_ID_SHIFT) | (workerId << WORKER_ID_SHIFT) | sequence; } private long tilNextMillis(long lastTimestamp) { long timestamp = timeGen(); while (timestamp <= lastTimestamp) { timestamp = timeGen(); } return timestamp; } private long timeGen() { return System.currentTimeMillis(); } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值