Java中生成唯一ID的方法

有時我們不依賴於數據庫中自動遞增的字段產生唯一ID,比如多表同一字段需要統一一個唯一ID,這時就需要用程序來生成一個唯一的全局ID。

UUID

從Java 5開始， UUID 類提供了一種生成唯一ID的簡單方法。UUID是通用唯一識別碼 (Universally Unique Identifier)的縮寫，UUID來源於OSF(Open Software Foundation，開源軟件基金會)的DCE(Distributed Computing Environment，分佈式計算環境)規範。UUID 的目的，是讓分佈式系統中的所有元素，都能有唯一的辨識資訊，而不需要透過中央控制端來做辨識資訊的指定。如此一來，每個人都可以建立不與其它人衝突的 UUID。

UUID是一個128bit的數字，也可以表現爲32個16進制的字符（每個字符0-F的字符代表4bit），中間用"-"分割。

• 時間戳＋UUID版本號： 分三段佔16個字符(60bit+4bit)，
• Clock Sequence號與保留字段：佔4個字符(13bit＋3bit)，
• 節點標識：佔12個字符(48bit)，

UUID的唯一缺陷在於生成的結果串會比較長。

public class GenerateUUID {
    public static final void main(String... args) {
        // generate random UUIDs
        UUID idOne = UUID.randomUUID();
        UUID idTwo = UUID.randomUUID();
        log("UUID One: " + idOne);
        log("UUID Two: " + idTwo);
    }

    private static void log(Object object) {
        System.out.println(String.valueOf(object));
    }
}

結果爲

UUID One: 6b193443-b95d-4462-9902-a6455ebc56d6
UUID Two: 4ef9b375-839b-4150-8f31-1ed85fab63fd

隨機數的哈希值

此方法使用SecureRandom和MessageDigest：

• 啓動時，初始化SecureRandom （這可能是一個冗長的操作）
• 使用 SecureRandom生成一個隨機數
• 創建一個MessageDigest，使用某種摘要算法
• 將MessageDigest返回的byte[]編碼爲某種可接受的文本形式
• 檢查結果是否已經被使用；如果尚未使用，則適合作爲唯一標識符

MessageDigest類是適合於產生任意數據的“單向散列”。

public class GenerateId {
    public static void main(String... arguments) {
        try {
            SecureRandom prng = SecureRandom.getInstance("SHA1PRNG");

            String randomNum = Integer.valueOf(prng.nextInt()).toString();

            MessageDigest sha = MessageDigest.getInstance("SHA-1");
            byte[] result = sha.digest(randomNum.getBytes());

            System.out.println("Random number: " + randomNum);
            System.out.println("Message digest: " + hexEncode(result));
        } catch (NoSuchAlgorithmException ex) {
            System.err.println(ex);
        }
    }

    static private String hexEncode(byte[] input) {
        StringBuilder result = new StringBuilder();
        char[] digits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
                'b', 'c', 'd', 'e', 'f'};
        for (int idx = 0; idx < input.length; ++idx) {
            byte b = input[idx];
            result.append(digits[(b & 0xf0) >> 4]);
            result.append(digits[b & 0x0f]);
        }
        return result.toString();
    }
}

結果爲

Random number: -2017013782
Message digest: 2c3bba8d4dbd3699648c5909685d21f9c64b6a8a

Twitter的snowflake

twitter的一個全局唯一id生成器，結果是一個long型的ID。

• 正數位(1bit)：一個符號位，永遠是0。
• 時間戳(41bit) ：自從2012年以來的毫秒數，能撐139年。
• 自增序列(12bit，最大值4096)：毫秒之內的自增，過了一毫秒會重新置0。
• DataCenter ID (5 bit, 最大值32）：配置值，支持多機房。
• Worker ID ( 5 bit, 最大值32)，配置值，一個機房裏最多32個機器。

Snowflake算法的變化

Snowflake算法生成的唯一ID爲long型數值，但如果想在應用中使用int類型的自增ID的話可以做些調整。

時間戳改爲分鐘（25bit），自增序列（7bit）。自增序列最大值128，在一分鐘內會不夠使用。可以採用預支方式取下一分鐘。

此方式只適用於一個單體應用，不適合分佈式系統。

/**
 * @ClassName: SnowflakeIdWorker3rd
 * @Description:snowflake算法改進
 * @author: wanghao
 * @date: 2019年12月13日 下午12:50:47
 * @version V1.0
 * 
 *          將產生的Id類型更改爲Integer 32bit <br>
 *          把時間戳的單位改爲分鐘,使用25個比特的時間戳（分鐘） <br>
 *          去掉機器ID和數據中心ID <br> 
 *          7個比特作爲自增值，即2的7次方等於128。
 */
public class SnowflakeIdWorker3rd {
    /** 開始時間戳 (2019-01-01) */
    private final int twepoch = 25771200;// 1546272000000L/1000/60;

    /** 序列在id中佔的位數 */
    private final long sequenceBits = 7L;

    /** 時間截向左移7位 */
    private final long timestampLeftShift = sequenceBits;

    /** 生成序列的掩碼，這裏爲127 */
    private final int sequenceMask = -1 ^ (-1 << sequenceBits);

    /** 分鐘內序列(0~127) */
    private int sequence = 0;
    private int laterSequence = 0;

    /** 上次生成ID的時間戳 */
    private int lastTimestamp = -1;

    private final MinuteCounter counter = new MinuteCounter();
    
    /** 預支時間標誌位 */
    boolean isAdvance = false;

    // ==============================Constructors=====================================
    public SnowflakeIdWorker3rd() {

    }

    // ==============================Methods==========================================
    /**
     * 獲得下一個ID (該方法是線程安全的)
     * 
     * @return SnowflakeId
     */
    public synchronized int nextId() {
        
        
        int timestamp = timeGen();
        // 如果當前時間小於上一次ID生成的時間戳，說明系統時鐘回退過這個時候應當拋出異常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format(
                    "Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
        
        if(timestamp > counter.get()) {
            counter.set(timestamp);
            isAdvance = false;
        }

        // 如果是同一時間生成的，則進行分鐘內序列
        if (lastTimestamp == timestamp || isAdvance) {
            if(!isAdvance) {
                sequence = (sequence + 1) & sequenceMask;
            }

            // 分鐘內自增列溢出
            if (sequence == 0) {
                // 預支下一個分鐘,獲得新的時間戳
                isAdvance = true;
                int laterTimestamp = counter.get();
                if (laterSequence == 0) {
                    laterTimestamp = counter.incrementAndGet();
                }

                int nextId = ((laterTimestamp - twepoch) << timestampLeftShift) //
                        | laterSequence;
                laterSequence = (laterSequence + 1) & sequenceMask;
                return nextId;
            }
        }
        // 時間戳改變，分鐘內序列重置
        else {
            sequence = 0;
            laterSequence = 0;
        }

        // 上次生成ID的時間截
        lastTimestamp = timestamp;

        // 移位並通過或運算拼到一起組成32位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | sequence;
    }

    /**
     * 返回以分鐘爲單位的當前時間
     * 
     * @return 當前時間(分鐘)
     */
    protected int timeGen() {
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000 / 60);
        return Integer.valueOf(timestamp);
    }

    // ==============================Test=============================================
    /** 測試 */
    public static void main(String[] args) {
        SnowflakeIdWorker3rd idWorker = new SnowflakeIdWorker3rd();
        for (int i = 0; i < 1000; i++) {
            long id = idWorker.nextId();
            System.out.println(i + ": " + id);
        }
    }
}

public class MinuteCounter {
    private static final int MASK = 0x7FFFFFFF;
    private final AtomicInteger atom;
    
    public MinuteCounter() {
        atom = new AtomicInteger(0);
    }
    
    public final int incrementAndGet() {
        return atom.incrementAndGet() & MASK;
    }
    
    public int get() {
        return atom.get() & MASK;
    }
    
    public void set(int newValue) {
        atom.set(newValue & MASK);
    }
}