算法原理
SnowFlake算法生成id的結果是一個64bit大小的整數，它的結構如下圖：
由於在Java中64bit的整數是long類型，所以在Java中SnowFlake算法生成的id就是long來存儲的。
SnowFlake可以保證：
- 所有生成的id按時間趨勢遞增
- 整個分佈式系統內不會產生重複id（因爲有datacenterId和machineId來做區分）
算法實現（Java）
Twitter官方給出的算法實現 是用Scala寫的，這裏不做分析，可自行查看。
/**
* * SnowFlake的結構如下(每部分用-分開):<br>
* * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 -
* 000000000000 <br>
* * 1位標識，由於long基本類型在Java中是帶符號的，最高位是符號位，正數是0，負數是1，所以id一般是正數，最高位是0<br>
* * 41位時間截(毫秒級)，注意，41位時間截不是存儲當前時間的時間截，而是存儲時間截的差值（當前時間截 - 開始時間截) *
* 得到的值），這裏的的開始時間截，一般是我們的id生成器開始使用的時間，由我們程序來指定的（如下下面程序IdWorker類的startTime屬性）。41位的時間截，可以使用69年，年T
* = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
* * 10位的數據機器位，可以部署在1024個節點，包括5位datacenterId和5位workerId<br>
* * 12位序列，毫秒內的計數，12位的計數順序號支持每個節點每毫秒(同一機器，同一時間截)產生4096個ID序號<br>
* * 加起來剛好64位，爲一個Long型。<br>
* *
* SnowFlake的優點是，整體上按照時間自增排序，並且整個分佈式系統內不會產生ID碰撞(由數據中心ID和機器ID作區分)，並且效率較高，經測試，SnowFlake每秒能夠產生20多萬ID左右。
* @author 80000636
*/
public class SnowflakeIdWorker {
private static final Logger logger = LoggerFactory.getLogger(SnowflakeIdWorker.class);
/**
* 起始的時間戳
*/
private final static long START_STMP = 1480166465631L;
/**
* 每一部分佔用的位數
*/
private final static long SEQUENCE_BIT = 10; //序列號佔用的位數
private final static long MACHINE_BIT = 5; //機器標識佔用的位數
private final static long DATACENTER_BIT = 5;//數據中心佔用的位數
/**
* 每一部分的最大值
*/
public final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
public final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);
/**
* 每一部分向左的位移
*/
private final static long MACHINE_LEFT = SEQUENCE_BIT;
private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;
private long datacenterId; //數據中心
private long machineId; //機器標識
private long sequence = 0L; //序列號
private long lastStmp = -1L;//上一次時間戳
/**
* 根據MAC生成datacenterId，根據MAC + PID生成machineId
*/
public SnowflakeIdWorker() {
long datacenterId = getDatacenterId(MAX_DATACENTER_NUM);
long machineId = getMachineId(datacenterId, MAX_MACHINE_NUM);
check(datacenterId, machineId);
this.datacenterId = datacenterId;
this.machineId = machineId;
}
/**
* datacenterId和machineId可配置
* @param datacenterId
* @param machineId
*/
public SnowflakeIdWorker(long datacenterId, long machineId) {
check(datacenterId, machineId);
this.datacenterId = datacenterId;
this.machineId = machineId;
}
private static void check(long datacenterId, long machineId) {
if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
throw new EompRuntimeException(String.format("datacenterId can't be greater than %s or less than 0", MAX_DATACENTER_NUM));
}
if (machineId > MAX_MACHINE_NUM || machineId < 0) {
throw new EompRuntimeException(String.format("machineId can't be greater than %s or less than 0", MAX_MACHINE_NUM));
}
}
/**
* 產生下一個ID
*
* @return
*/
public synchronized long nextId() {
long currStmp = getNewstmp();
if (currStmp < lastStmp) {
throw new EompRuntimeException("Clock moved backwards. Refusing to generate id");
}
if (currStmp == lastStmp) {
//相同毫秒內，序列號自增
sequence = (sequence + 1) & MAX_SEQUENCE;
//同一毫秒的序列數已經達到最大
if (sequence == 0L) {
currStmp = getNextMill();
}
} else {
//不同毫秒內，序列號置爲0
sequence = 0L;
}
lastStmp = currStmp;
return (currStmp - START_STMP) << TIMESTMP_LEFT //時間戳部分
| datacenterId << DATACENTER_LEFT //數據中心部分
| machineId << MACHINE_LEFT //機器標識部分
| sequence; //序列號部分
}
/**
* 阻塞到下一個毫秒，直到獲得新的時間戳
* @return 當前時間戳
*/
private long getNextMill() {
long mill = getNewstmp();
while (mill <= lastStmp) {
mill = getNewstmp();
}
return mill;
}
/**
* 返回以毫秒爲單位的當前時間
* @return 當前時間(毫秒)
*/
private long getNewstmp() {
return System.currentTimeMillis();
}
/**
* 機器標識
*/
private static long getMachineId(long datacenterId, long maxWorkerId) {
StringBuilder mpid = new StringBuilder();
mpid.append(datacenterId);
String name = ManagementFactory.getRuntimeMXBean().getName();
if (!name.isEmpty()) {
/** GET jvmPid */
mpid.append(name.split("@")[0]);
}
/** MAC + PID 的 hashcode 獲取16個低位 */
return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
}
/**
* 數據標識id部分
*/
private static long getDatacenterId(long maxDatacenterId) {
long id = 0L;
try {
InetAddress ip = InetAddress.getLocalHost();
NetworkInterface network = NetworkInterface.getByInetAddress(ip);
if (network == null) {
id = 1L;
} else {
byte[] mac = network.getHardwareAddress();
id = ((0x000000FF & (long) mac[mac.length - 1])
| (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
id = id % (maxDatacenterId + 1);
}
} catch (Exception e) {
logger.error("getDatacenterId exception.", e);
}
return id;
}
/*public static void main(String[] args) {
long datacenterId = getDatacenterId(MAX_DATACENTER_NUM);
long machineId = getMachineId(datacenterId, MAX_MACHINE_NUM);
System.out.println("ip:" + datacenterId + ",processId:" + machineId);
}*/
}
測試類：
public class SnowflakeIdWorkerTest {
public static Set<Long> idSet = new HashSet<>();
public static void main(String[] args) {
SnowflakeIdWorker snowflakeIdWorker = new SnowflakeIdWorker(1, 0);
for (long i = 0; i < 1000; i++) {
new Thread(new Worker(snowflakeIdWorker)).start();
}
}
static class Worker implements Runnable {
private SnowflakeIdWorker snowflakeIdWorker;
public Worker(SnowflakeIdWorker snowflakeIdWorker) {
this.snowflakeIdWorker = snowflakeIdWorker;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
Long id = snowflakeIdWorker.nextId();
if (!idSet.add(id)) {
System.err.println("存在重複id:" + id);
}
}
}
}
}