JAVA SNOWFLAKE 生成唯一ID

snowflake方案
snowflake是Twitter開源的分佈式ID生成算法，結果是一個long型的ID。

這種方案大致來說是一種以劃分命名空間（UUID也算，由於比較常見，所以單獨分析）來生成ID的一種算法，這種方案把64-bit分別劃分成多段，分開來標示機器、時間等。

其核心思想是：使用41bit作爲毫秒數，10bit作爲機器的ID（5個bit是數據中心，5個bit的機器ID），12bit作爲毫秒內的流水號，最後還有一個符號位，永遠是0。

比如在snowflake中的64-bit分別表示如下圖（圖片來自網絡）所示：

整個結構是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。10-bit機器可以分別表示1024臺機器。如果我們對IDC劃分有需求，還可以將10-bit分5-bit給IDC，分5-bit給工作機器。這樣就可以表示32個IDC，每個IDC下可以有32臺機器，可以根據自身需求定義。
12位序列，毫秒內的計數，12位的計數順序號支持每個節點每毫秒(同一機器，同一時間截)產生4096個ID序號。12個自增序列號可以表示2^12個ID，理論上snowflake方案的QPS約爲409.6w/s，這種分配方式可以保證在任何一個IDC的任何一臺機器在任意毫秒內生成的ID都是不同的。
加起來剛好64位，爲一個Long型。

優點：

整體上按照時間自增排序，並且整個分佈式系統內不會產生ID碰撞(由數據中心ID和機器ID作區分)，並且效率較高，經測試，SnowFlake每秒能夠產生26萬ID左右。

毫秒數在高位，自增序列在低位，整個ID都是趨勢遞增的。不依賴數據庫等第三方系統，以服務的方式部署，穩定性更高，生成ID的性能也是非常高的。
可以根據自身業務特性分配bit位，非常靈活。

缺點：

強依賴機器時鐘，如果機器上時鐘回撥，會導致發號重複或者服務會處於不可用狀態。
針對此，美團做出了改進：https://github.com/Meituan-Dianping/Leaf

SnowFlake算法代碼

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實現方式1
apache.commons.lang3包

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.6</version>
</dependency>

讀取配置文件：https://blog.csdn.net/fly910905/article/details/78737323
工具類

package com.datalook.util.common;
 
import org.apache.commons.lang3.time.DateFormatUtils;
 
 
import java.util.Date;
/**
 * 
 * @Title:  訂單號生成
 * @ClassName:OrderIdUtils.java
 * @Description:
 *
 * @author: MHC
 * @date:2018年3月2日 下午17:43:30
 * @version V1.0
 */
public class OrderIdUtils {
 
    // 最近的時間戳
    private long lastTimestamp=0;
    //機器id 2位
    private final String machineId;
    // 0，併發控制
    private long sequence = 0L;
    // 序列號的最大值
    private final int sequenceMax = 9999;
 
 
    public OrderIdUtils(String machineId) {
        this.machineId = machineId;
    }
 
    /**
     * 生成訂單號
     */
    public synchronized String nextId(){
        Date now=new Date();
        String time= DateFormatUtils.format(now,"yyMMddHHmmssSSS");
        long timestamp = now.getTime();
        if (this.lastTimestamp == timestamp) {
            // 如果上一個timestamp與新產生的相等，則sequence加一(0-4095循環);
            // 對新的timestamp，sequence從0開始
            this.sequence = this.sequence + 1 % this.sequenceMax;
            if (this.sequence == 0) {
                // 重新生成timestamp
                timestamp = this.tilNextMillis(this.lastTimestamp);
            }
        } else {
            this.sequence = 0;
        }
        this.lastTimestamp= timestamp;
        StringBuilder sb=new StringBuilder(time).append(machineId).append(leftPad(sequence,4));
        return sb.toString();
    }
 
    /**
     * 補碼
     * @param i
     * @param n
     * @return
     */
    private String leftPad(long i,int n){
        String s = String.valueOf(i);
        StringBuilder sb=new StringBuilder();
        int c=n-s.length();
        c=c<0?0:c;
        for (int t=0;t<c;t++){
            sb.append("0");
        }
        return sb.append(s).toString();
    }
 
    /**
     * 等待下一個毫秒的到來, 保證返回的毫秒數在參數lastTimestamp之後
     */
    private long tilNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
 
    // 這裏讀取的是配置文件
    // 機器id(我這裏是01,正式環境建議使用機器IP)
    // 注意：分佈式環境,注意每臺機器的id要保證不同;也可以使用機器ip,映射成一個數字編號（如01:192.168.55.12）
    private static String myid= SysConstant.LOCAL_MACHINE_ID;
 
    // 示例
    private static OrderIdUtils instance = new OrderIdUtils(myid);
    public static OrderIdUtils getInstance() {
        return instance;
    }
    
    
    
    /**
     * 
     * @Title: 獲取訂單號
     * @return String
     * @Description:
     *
     * @author: MHC
     * @date: 2018年3月2日 下午17:56:56
     */
    public static  String getOrderNumber() {
 
        OrderIdUtils orderId = OrderIdUtils.getInstance();
        String nextId = orderId.nextId();
 
        return nextId;
    }
 
    /**
     * 調用
     */
    public static void main(String[] args) {
        OrderIdUtils orderId= OrderIdUtils.getInstance();
        String nextId = orderId.nextId();
        int length = nextId.length();
        System.out.println(nextId);
        System.out.println(length);
 
    }
}

snowflake實現方式2
引入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);
        }
    }
 
    /**
     * 獲取一個批次號，形如 2019071015301361011101237
     * <p>
     * 數據庫使用 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
     * <p>
     * ObjectId 是 MongoDB 數據庫的一種唯一 ID 生成策略，
     * 是 UUID version1 的變種，詳細介紹可見：服務化框架－分佈式 Unique ID 的生成方法一覽。
     *
     * @return
     */
    public String objectId() {
        return ObjectId.next();
    }
 
}

JAVA SNOWFLAKE 生成唯一ID

一個簡單的MD5加鹽

C# 代碼學習

藍橋15屆stema編程題密碼鎖-動態規劃 C++和Python最後一道題

2021看雪SDC議題回顧 | SaTC：一種全新的物聯網設備漏洞自動化挖掘方法

Kafka存儲機制

aws語音呼叫調用，告警電話

【轉】[C#] WebAPI 防止併發調用二（冥等性）

C#/.NET/.NET Core優秀項目和框架2024年4月簡報

HTTP URL 詳解

得物 ZooKeeper SLA 也可以 99.99%

優雅的寫出switch

JAVA SNOWFLAKE 生成唯一ID

程序之美----吊炸天的程序員才寫的註釋

服務器RabbitMQ 安裝

全網最強密碼規則效驗（java後臺版和javascript版）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結