全局唯一訂單號生成方法（參考snowflake）

backgroud

Snowflake is a network service for generating unique ID numbers at high scale with some simple guarantees.

簡介

對於一個較大的訂購業務場景，我們往往需要能夠生成一個全局的唯一的訂單號，如何在多個集群，多個節點高效生成唯一訂單號？我們參考了Twitter的snowflake算法。

snowflake最初由Twitter開發，用的scala，對於Twitter而言，必須滿足每秒上萬條消息的請求，並且每條消息能夠分配一個全局唯一的ID，因此，ID生成服務要求必須滿足高性能（>10K ids/s）、低延遲（<2ms）、高可用的特性，同時生成的ID還可以進行大致的排序，以方便客戶端的排序。

Snowflake滿足了以上的需求。Snowflake生成的每一個ID都是64位的整型數，它的核心算法也比較簡單高效，結構如下：

• 41位的時間序列，精確到毫秒級，41位的長度可以使用69年。時間位還有一個很重要的作用是可以根據時間進行排序。

• 10位的機器標識，10位的長度最多支持部署1024個節點。

• 12位的計數序列號，序列號即一系列的自增id，可以支持同一節點同一毫秒生成多個ID序號，12位的計數序列號支持每個節點每毫秒產生4096個ID序號。

• 最高位是符號位，始終為0，不可用。

原生算法java實現


/** 
* 摘自網上某blog，記不得地址了。。 
* @Project concurrency 
* Created by wgy on 16/7/19. 
*/ 
public class IdGen { 
private long workerId; 
private long datacenterId; 
private long sequence = 0L; 
private long twepoch = 1288834974657L; //Thu, 04 Nov 2010 01:42:54 GMT 
private long workerIdBits = 5L; //節點ID長度 
private long datacenterIdBits = 5L; //數據中心ID長度 
private long maxWorkerId = -1L ^ (-1L << workerIdBits); //最大支持機器節點數0~31，一共32個 
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); //最大支持數據中心節點數0~31，一共32個 
private long sequenceBits = 12L; //序列號12位 
private long workerIdShift = sequenceBits; //機器節點左移12位 
private long datacenterIdShift = sequenceBits + workerIdBits; //數據中心節點左移17位 
private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; //時間毫秒數左移22位 
private long sequenceMask = -1L ^ (-1L << sequenceBits); //4095 
private long lastTimestamp = -1L; 
private static class IdGenHolder { 
private static final IdGen instance = new IdGen(); 
} 
public static IdGen get(){ 
return IdGenHolder.instance; 
} 
public IdGen() { 
this(0L, 0L); 
} 
public IdGen(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; 
} 
public synchronized long nextId() { 
long timestamp = timeGen(); //獲取當前毫秒數 
//如果服務器時間有問題(時鍾后退) 報錯。 
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只有12bit，所以和sequenceMask相與一下，去掉高位 
sequence = (sequence + 1) & sequenceMask; 
//判斷是否溢出,也就是每毫秒內超過4095，當為4096時，與sequenceMask相與，sequence就等於0 
if (sequence == 0) { 
timestamp = tilNextMillis(lastTimestamp); //自旋等待到下一毫秒 
} 
} else { 
sequence = 0L; //如果和上次生成時間不同,重置sequence，就是下一毫秒開始，sequence計數重新從0開始累加 
} 
lastTimestamp = timestamp; 
// 最后按照規則拼出ID。 
// 000000000000000000000000000000000000000000 00000 00000 000000000000 
// time datacenterId workerId sequence 
return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift) 
| (workerId << workerIdShift) | sequence; 
} 
protected long tilNextMillis(long lastTimestamp) { 
long timestamp = timeGen(); 
while (timestamp <= lastTimestamp) { 
timestamp = timeGen(); 
} 
return timestamp; 
} 
protected long timeGen() { 
return System.currentTimeMillis(); 
} 
} 


注釋已經寫的比較詳細了，不做特別的說明。

訂購業務唯一訂單號實現

對於訂購業務而言，雖然可以記錄訂單的創建時間，但是一般都需要帶有顯示的時間戳屬性。因此，一個long型已無法滿足實際的需求，將輸出修改為String類型，前17位用於存儲yyyyMMddHHMMssSSS格式的時間，后面用於記錄所在集群，節點，以及自增量。


import org.apache.commons.lang.time.DateFormatUtils;

import java.net.InetAddress; 
import java.net.UnknownHostException; 
import java.util.Date;

/** 
* 與snowflake算法區別,返回字符串id,占用更多字節,但直觀從id中看出生成時間 
* 
* @Project concurrency 
* Created by wgy on 16/7/19. 
*/ 
public enum IdGenerator {

INSTANCE;

private long workerId;   //用ip地址最后幾個字節標示
private long datacenterId = 0L; //可配置在properties中,啟動時加載,此處默認先寫成0
private long sequence = 0L;
private long workerIdBits = 8L; //節點ID長度
private long datacenterIdBits = 2L; //數據中心ID長度,可根據時間情況設定位數
private long sequenceBits = 12L; //序列號12位
private long workerIdShift = sequenceBits; //機器節點左移12位
private long datacenterIdShift = sequenceBits + workerIdBits; //數據中心節點左移14位
private long sequenceMask = -1L ^ (-1L << sequenceBits); //4095
private long lastTimestamp = -1L;

IdGenerator(){
    workerId = 0x000000FF & getLastIP();
}


public synchronized String nextId() {
    long timestamp = timeGen(); //獲取當前毫秒數
    //如果服務器時間有問題(時鍾后退) 報錯。
    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只有12bit，所以和sequenceMask相與一下，去掉高位
        sequence = (sequence + 1) & sequenceMask;
        //判斷是否溢出,也就是每毫秒內超過4095，當為4096時，與sequenceMask相與，sequence就等於0
        if (sequence == 0) {
            timestamp = tilNextMillis(lastTimestamp); //自旋等待到下一毫秒
        }
    } else {
        sequence = 0L; //如果和上次生成時間不同,重置sequence，就是下一毫秒開始，sequence計數重新從0開始累加
    }
    lastTimestamp = timestamp;


    long suffix = (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence;

    String datePrefix = DateFormatUtils.format(timestamp, "yyyyMMddHHMMssSSS");

    return datePrefix + suffix;
}

protected long tilNextMillis(long lastTimestamp) {
    long timestamp = timeGen();
    while (timestamp <= lastTimestamp) {
        timestamp = timeGen();
    }
    return timestamp;
}

protected long timeGen() {
    return System.currentTimeMillis();
}

private byte getLastIP(){
    byte lastip = 0;
    try{
        InetAddress ip = InetAddress.getLocalHost();
        byte[] ipByte = ip.getAddress();
        lastip = ipByte[ipByte.length - 1];
    } catch (UnknownHostException e) {
        e.printStackTrace();
    }
    return lastip;
}

}

 

測試

測試環境

• macbook Pro 2.4 GHz Intel Core i5 4 GB 1600 MHz DDR3

• 10個線程，每個線程生成5w個

  需2000ms左右，測試代碼如下：

測試代碼


@Test 
public void testNextId() throws Exception { 
final IdGenerator idg = IdGenerator.INSTANCE; 
ExecutorService es = Executors.newFixedThreadPool(10); 
final HashSet idSet = new HashSet(); 
Collections.synchronizedCollection(idSet); 
long start = System.currentTimeMillis(); 
System.out.println(" start generate id *"); 
for (int i = 0; i < 10; i++) 
es.execute(new Runnable() { 
public void run() { 
for (int j = 0; j < 50000; j++) { 
String id= idg.nextId(); 
synchronized (idSet){ 
idSet.add(id); 
} 
} 
} 
}); 
es.shutdown(); 
es.awaitTermination(10, TimeUnit.SECONDS); 
long end = System.currentTimeMillis(); 
System.out.println(" end generate id "); 
System.out.println("* cost " + (end-start) + " ms!"); 
Assert.assertEquals(10 * 50000, idSet.size()); 
} 


測試結果

start generate id * 
end generate id * 
* cost 2091 ms!