我們在開發中，有時非常需要一個全局唯一的ID值，不管是業務需求，還是為了以后可能的分表需求，全局唯一值都非常有用，本篇大象就來講講這個實現并對ID生成器性能進行一下測試。
大象所講的這個全局唯一ID生成器，其實是Twitter公開的一個算法，源碼是用Scala寫的，被國內的開源愛好者改寫成了Java版本。
大象將這個類的調用簡化了一下，實際使用中還是應該根據機器節點和數據中心節點來配置相關的參數。我這里假設只有一個節點作為ID號的生成器，所以workerId和datacenterId都設為0，當前時間與計算標記時間twepoch（Thu, 04 Nov 2010 01:42:54 GMT）之間的毫秒數是一個38位長度的long值，再左移timestampLeftShift（22位），就得到一個60位長度的long數字，該數字與datacenterId << datacenterIdShift取或，datacenterId最小值為0，最大值為31，所以長度為1-5位，datacenterIdShift是17位，所以結果就是最小值為0，最大值為22位長度的long，同理，workerId << workerIdShift的最大值為17位的long。所以最終生成的會是一個60位長度的long型唯一ID
我直接貼代碼，有部分注釋，有一小部分我還沒完全看懂，請明白的告訴我一下。
/**
* 全局唯一ID生成器
*/
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();
}
}
接下來我再寫個測試類，看下并發情況下，1秒鐘可以生成多少個ID。我測試用的電腦CPU為I5-4210U，內存8G，JDK為1.7.0_79，系統是64位WIN 7，使用-server模式。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
public class GeneratorTest {
@Test
public void testIdGenerator() {
long avg = 0;
for (int k = 0; k < 10; k++) {
List<Callable<Long>> partitions = new ArrayList<Callable<Long>>();
final IdGen idGen = IdGen.get();
for (int i = 0; i < 1400000; i++) {
partitions.add(new Callable<Long>() {
@Override
public Long call() throws Exception {
return idGen.nextId();
}
});
}
ExecutorService executorPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
try {
long s = System.currentTimeMillis();
executorPool.invokeAll(partitions, 10000, TimeUnit.SECONDS);
long s_avg = System.currentTimeMillis() - s;
avg += s_avg;
System.out.println("完成時間需要: " + s_avg / 1.0e3 + "秒");
executorPool.shutdown();
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println("平均完成時間需要: " + avg / 10 / 1.0e3 + "秒");
}
}
運行10次，平均下來，每次1.038秒生成140萬個ID，除了第1次時間在3秒左右和第2次1.6秒左右，其余8次都在0.7秒左右。如果使用更好的硬件，測試數據肯定會更好。因此從大的方向上看，單節點的ID生成器基本上可以滿足我們的需要了。
需要注意的是，該值只是一個唯一值，但并不能保證會是一個順序值，就是說兩個ID之間可能會跳一些數字，所以對于一些有特殊需求的業務來說請注意這個差異。
本文為菠蘿大象原創，如要轉載請注明出處。http://www.aygfsteel.com/bolo
posted on 2015-07-13 17:22
菠蘿大象 閱讀(20491)
評論(2) 編輯 收藏 所屬分類:
Java