分佈式id生成器

鏈接：https://juejin.im/post/5d8882d8f265da03e369c063

在高併發或者分表分庫情況下怎麼保證數據id的冪等性呢

經常用到的解決方案有以下幾種。

微軟公司通用唯一識別碼（UUID）

Twitter公司雪花算法（SnowFlake）

基於數據庫的id自增

對id進行緩存

這裡我們要談到snowflake算法了

snowflake是Twitter開源的分佈式ID生成算法，結果是一個long型的ID。其核心思想是：使用41bit作為毫秒數，10bit作為機器的ID（5個bit是數據中心，5個bit的機器ID），12bit作為毫秒內的流水號，最後還有一個符號位，永遠是0。 snowflake算法所生成的ID結構

整個結構是64位，所以我們在Java中可以使用long來進行存儲。 該算法實現基本就是二進制操作,單機每秒內理論上最多可以生成1024*(2^12)，也就是409.6萬個ID(1024 X 4096 = 4194304)

 
 * 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左右。 

複製代碼

snowFlake算法的優點：

1.生成ID時不依賴於DB，完全在內存生成，高性能高可用。 2.ID呈趨勢遞增，後續插入索引樹的時候性能較好。

SnowFlake算法的缺點：

依賴於系統時鐘的一致性。如果某臺機器的系統時鐘回撥，有可能造成ID衝突，或者ID亂序

算法代碼如下

public class SnowflakeIdWorker {
 // ==============================Fields==================
 /** 開始時間截 (2019-08-06) */
 private final long twepoch = 1565020800000L;
 /** 機器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====================
 /**
 * 構造函數
 * @param workerId 工作ID (0~31)
 * @param datacenterId 數據中心ID (0~31)
 */
 public SnowflakeIdWorker(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=================================
 /**
 * 獲得下一個ID (該方法是線程安全的)
 * @return SnowflakeId
 */
 public synchronized long nextId() {
 long timestamp = timeGen();
 //如果當前時間小於上一次ID生成的時間戳，說明系統時鐘回退過這個時候應當拋出異常
 if (timestamp < lastTimestamp) {
 throw new RuntimeException(
 String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp)); 

 }
 //如果是同一時間生成的，則進行毫秒內序列
 if (lastTimestamp == timestamp) {
 sequence = (sequence + 1) & sequenceMask;
 //毫秒內序列溢出
 if (sequence == 0) {
 //阻塞到下一個毫秒,獲得新的時間戳
 timestamp = tilNextMillis(lastTimestamp);
 }
 }
 //時間戳改變，毫秒內序列重置
 else {
 sequence = 0L;
 }
 //上次生成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) {
 SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
 for (int i = 0; i < 1000; i++) {
 long id = idWorker.nextId();
 System.out.println(Long.toBinaryString(id));
 System.out.println(id);
 }
 }
}
複製代碼

快速使用snowflake算法只需以下幾步

引入hutool依賴

<dependency>
 <groupid>cn.hutool/<groupid>
 <artifactid>hutool-captcha/<artifactid>
 <version>${hutool.version}/<version>
/<dependency>
複製代碼

ID 生成器

public class IdGenerator {
 private long workerId = 0;
 @PostConstruct
 void init() {
 try {
 workerId = NetUtil.ipv4ToLong(NetUtil.getLocalhostStr());
 log.info("當前機器 workerId: {}", workerId);
 } catch (Exception e) {
 log.warn("獲取機器 ID 失敗", e);
 workerId = NetUtil.getLocalhost().hashCode();
 log.info("當前機器 workerId: {}", workerId);
 }
 }
 /**
 * 獲取一個批次號，形如 2019071015301361000101237 

 * 

 * 數據庫使用 char(25) 存儲
 *
 * @param tenantId 租戶ID，5 位
 * @param module 業務模塊ID，2 位
 * @return 返回批次號
 */
 public synchronized String batchId(int tenantId, int module) {
 String prefix = DateTime.now().toString(DatePattern.PURE_DATETIME_MS_PATTERN);
 return prefix + tenantId + module + RandomUtil.randomNumbers(3);
 }
 @Deprecated
 public synchronized String getBatchId(int tenantId, int module) {
 return batchId(tenantId, module);
 }
 /**
 * 生成的是不帶-的字符串，類似於：b17f24ff026d40949c85a24f4f375d42
 *
 * @return
 */
 public String simpleUUID() {
 return IdUtil.simpleUUID();
 }
 /**
 * 生成的UUID是帶-的字符串，類似於：a5c8a5e8-df2b-4706-bea4-08d0939410e3
 *
 * @return
 */
 public String randomUUID() {
 return IdUtil.randomUUID();
 }
 private Snowflake snowflake = IdUtil.createSnowflake(workerId, 1);
 public synchronized long snowflakeId() {
 return snowflake.nextId();
 }
 public synchronized long snowflakeId(long workerId, long dataCenterId) {
 Snowflake snowflake = IdUtil.createSnowflake(workerId, dataCenterId);
 return snowflake.nextId();
 }
 /**
 * 生成類似：5b9e306a4df4f8c54a39fb0c
 * 
 

 * ObjectId 是 MongoDB 數據庫的一種唯一 ID 生成策略，
 * 是 UUID version1 的變種，詳細介紹可見：服務化框架－分佈式 Unique ID 的生成方法一覽。
 *
 * @return
 */
 public String objectId() {
 return ObjectId.next();
 }
}
複製代碼

測試類

public class IdGeneratorTest {
 @Autowired
 private IdGenerator idGenerator;
 @Test
 public void testBatchId() {
 for (int i = 0; i < 100; i++) {
 String batchId = idGenerator.batchId(1001, 100);
 log.info("批次號: {}", batchId);
 }
 }
 @Test
 public void testSimpleUUID() {
 for (int i = 0; i < 100; i++) {
 String simpleUUID = idGenerator.simpleUUID();
 log.info("simpleUUID: {}", simpleUUID);
 }
 }
 @Test
 public void testRandomUUID() {
 for (int i = 0; i < 100; i++) {
 String randomUUID = idGenerator.randomUUID();
 log.info("randomUUID: {}", randomUUID);
 }
 }
 @Test
 public void testObjectID() {
 for (int i = 0; i < 100; i++) {
 String objectId = idGenerator.objectId();
 log.info("objectId: {}", objectId);
 } 

 }
 @Test
 public void testSnowflakeId() {
 ExecutorService executorService = Executors.newFixedThreadPool(20);
 for (int i = 0; i < 20; i++) {
 executorService.execute(() -> {
 log.info("分佈式 ID: {}", idGenerator.snowflakeId());
 });
 }
 executorService.shutdown();
 }
}
複製代碼

在項目中我們只需要注入 @Autowired private IdGenerator idGenerator;即可

然後設置id order.setId(idGenerator.snowflakeId() + "");