在理解了這個算法以後，其實還有一些擴展的事情能夠作：
- 根據本身業務修改每一個位段存儲的信息。算法是通用的，能夠根據本身需求適當調整每段的大小以及存儲的信息。
- 解密id，因爲id的每段都保存了特定的信息，因此拿到一個id，應該能夠嘗試反推出原始的每一個段的信息。反推出的信息能夠幫助咱們分析。好比做爲訂單，能夠知道該訂單的生成日期，負責處理的數據中心等等.
Twitter的SnowFlake分佈式id生成算法
二進制相關知識回顧
一、全部的數據都是以二進制的形式存儲在硬盤上。對於一個字節的8位究竟是什麼類型 計算機是如何分辨的呢? 其實計算機並不負責判斷數據類型,數據類型是程序告訴計算機該如何解釋內存塊.java
二、對於字符的存儲，先將字符轉化成其字符集的碼點，（碼點就是一個數字），而後把該數字轉成2進制存儲。因此咱們只要記得數字的存儲就ok了。字符的碼點程序採用無符號處理，即沒有符號位，數值型默認都是有符號位的。git
1個字節的最高位是符號位因此一個數字可以存儲的範圍是-128-127github
3.原碼算法
正數5: 0000 0101windows
負數5: 1000 0101安全
4.反碼less
正數5: 0000 0101dom
負數5: 1111 1010分佈式
5.補碼函數
正數5: 0000 0101
負數5: 1111 1011（-5在硬盤上的存儲方式）
1.能夠看到正數的原碼 與 其反碼補碼相同 2.負數的原碼最高位爲1
3.負數的反碼： 符號位不變,其他各位按位取反
4.負數的補碼：在其反碼的基礎上+1
5.負數是以其補碼的方式存儲在硬盤上的
6.左移操做（<<）
規則： 右邊空出的位用0填補 高位左移溢出則捨棄該高位。 計算機中經常使用補碼錶示數據： 數據 127，補碼和原碼同樣：0111 1111。 左移一位： 1111 1110 -> 這個補碼對應的原碼爲：1000 0010 對應十進制：-2 左移二位： 1111 1100 -> 這個補碼對應的原碼爲：1000 0100 對應十進制：-4 左移三位： 1111 1000 -> 這個補碼對應的原碼爲：1000 1000 對應十進制：-8 左移四位： 1111 0000 -> 這個補碼對應的原碼爲：1001 0000 對應十進制：-16 左移五位： 1110 0000 -> 這個補碼對應的原碼爲：1010 0000 對應十進制：-32 左移六位： 1100 0000 -> 這個補碼對應的原碼爲：1100 0000 對應十進制：-64 左移七位： 1000 0000 -> 這個補碼對應的原碼爲：1000 0000 對應十進制：-128 左移八位： 0000 0000 -> 這個補碼對應的原碼爲：0000 0000 對應十進制：0 注： 原碼到補碼的計算方式：取反+1， 補碼到原碼的計算方式：-1再取反。 數據-1，它的原碼爲1000 0001,補碼爲1111 1111 左移一位： 1111 1110 -> 這個補碼對應的原碼爲：1000 0010 對應十進制：-2 左移二位： 1111 1100 -> 這個補碼對應的原碼爲：1000 0100 對應十進制：-4 左移三位： 1111 1000 -> 這個補碼對應的原碼爲：1000 1000 對應十進制：-8 左移四位： 1111 0000 -> 這個補碼對應的原碼爲：1001 0000 對應十進制：-16 左移五位： 1110 0000 -> 這個補碼對應的原碼爲：1010 0000 對應十進制：-32 左移六位： 1100 0000 -> 這個補碼對應的原碼爲：1100 0000 對應十進制：-64 左移七位： 1000 0000 -> 這個補碼對應的原碼爲：1000 0000 對應十進制：-128 左移八位： 0000 0000 -> 這個補碼對應的原碼爲：0000 0000 對應十進制：0 能夠看出127和-1的結果徹底同樣。移位操做與正負數無關，它只是忠實的將全部位進行移動，補0，捨棄操做。
7.右移操做( >>)
規則： 左邊空出的位用0或者1填補。正數用0填補，負數用1填補。注：不一樣的環境填補方式可能不一樣； 低位右移溢出則捨棄該位。 一、127的補碼：0111 1111 右移一位： 0011 1111 -> 原碼同補碼同樣 對應十進制：63 右移二位： 0001 1111 -> 原碼同補碼同樣 對應十進制：31 右移三位： 0000 1111 -> 原碼同補碼同樣 對應十進制：15 右移四位： 0000 0111 -> 原碼同補碼同樣 對應十進制：7 右移五位： 0000 0011 -> 原碼同補碼同樣 對應十進制：3 右移六位： 0000 0001 -> 原碼同補碼同樣 對應十進制：1 右移七位： 0000 0000 -> 原碼同補碼同樣 對應十進制：0 右移八位： 0000 0000 -> 原碼同補碼同樣 對應十進制：0 二、-128的補碼：1000 0000 右移一位： 1100 0000 -> 這個補碼對應的原碼爲：1100 0000 對應十進制：-64 右移二位： 1110 0000 -> 這個補碼對應的原碼爲：1010 0000 對應十進制：-32 右移三位： 1111 0000 -> 這個補碼對應的原碼爲：1001 0000 對應十進制：-16 右移四位： 1111 1000 -> 這個補碼對應的原碼爲：1000 1000 對應十進制：-8 右移五位： 1111 1100 -> 這個補碼對應的原碼爲：1000 0100 對應十進制：-4 右移六位： 1111 1110 -> 這個補碼對應的原碼爲：1000 0010 對應十進制：-2 右移七位： 1111 1111 -> 這個補碼對應的原碼爲：1000 0001 對應十進制：-1 右移八位： 1111 1111 -> 這個補碼對應的原碼爲：1000 0001 對應十進制：-1 常見應用 左移至關於*2，只是要注意邊界問題。如char a = 65； a<<1 按照*2來算爲130;但有符號char的取值範圍-128~127，已經越界，多超出了3個數值，因此從-128算起的第三個數值-126纔是a<<1的正確結果。 而右移至關於除以2，只是要注意移位比較多的時候結果會趨近去一個很是小的數，如上面結果中的-1，0。
八、與運算（&）
參與運算的兩個數據，按二進制位進行「與」運算
規則：0&0=0; 0&1=0; 1&0=0; 1&1=1;
即：兩位同時爲「1」，結果才爲「1」，不然爲0
九、或運算（|）
參加運算的兩個對象，按二進制位進行「或」運算。
運算規則：0|0=0； 0|1=1； 1|0=1； 1|1=1；
即 ：參加運算的兩個對象只要有一個爲1，其值爲1。
十、異或運算（^）
參加運算的兩個數據，按二進制位進行「異或」運算。
運算規則：0^0=0； 0^1=1； 1^0=1； 1^1=0；
即：參加運算的兩個對象，若是兩個相應位爲「異」（值不一樣），則該位結果爲1，不然爲0。
1位：不用，二進制中最高位爲1的都是負數，可是咱們生成的id通常都使用整數，因此這個最高位固定是0.
41位：用來記錄時間戳（毫秒）。
- 41位能夠表示2^41−1個數字，
- 若是隻用來表示正整數（計算機中正數包含0），能夠表示的數值範圍是：0 至 2^41−1，減1是由於可表示的數值範圍是從0開始算的，而不是1。
- 也就是說41位能夠表示2^41−1個毫秒的值，轉化成單位年則是(241−1)/(1000∗60∗60∗24∗365)=69年
16位：用來記錄工做機器id
- 能夠部署在2^10=1024個節點，包括
5位datacenterId和5位workerId 5位（bit）能夠表示的最大正整數是25−1=31，便可以用0、一、二、三、....31這32個數字，來表示不一樣的datecenterId或workerId
12位：序列號，用來記錄同毫秒內產生的不一樣id
12位（bit）能夠表示的最大正整數是212−1=4095，便可以用0、一、二、三、....4094這4095個數字，來表示同一機器同一時間截（毫秒)內產生的4095個ID序號
因爲在java中64bit的整數是long類型，因此在java中SnowFlake算法生成的id就是long來存儲的。
SnowFlake能夠保證：
- 全部生成的id按時間趨勢遞增
- 整個分佈式系統內不會產生重複id（由於有datacenterId和workerId來作區分）
/** Copyright 2010-2012 Twitter, Inc.*/
package com.twitter.service.snowflake
import com.twitter.ostrich.stats.Stats
import com.twitter.service.snowflake.gen._
import java.util.Random
import com.twitter.logging.Logger
/**
* An object that generates IDs.
* This is broken into a separate class in case
* we ever want to support multiple worker threads
* per process
*/
class IdWorker(val workerId: Long, val datacenterId: Long, private val reporter: Reporter, var sequence: Long = 0L)
extends Snowflake.Iface {
private[this] def genCounter(agent: String) = {
Stats.incr("ids_generated")
Stats.incr("ids_generated_%s".format(agent))
}
private[this] val exceptionCounter = Stats.getCounter("exceptions")
private[this] val log = Logger.get
private[this] val rand = new Random
val twepoch = 1288834974657L
private[this] val workerIdBits = 5L
private[this] val datacenterIdBits = 5L
private[this] val maxWorkerId = -1L ^ (-1L << workerIdBits)
private[this] val maxDatacenterId = -1L ^ (-1L << datacenterIdBits)
private[this] val sequenceBits = 12L
private[this] val workerIdShift = sequenceBits
private[this] val datacenterIdShift = sequenceBits + workerIdBits
private[this] val timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits
private[this] val sequenceMask = -1L ^ (-1L << sequenceBits)
private[this] var lastTimestamp = -1L
// sanity check for workerId
if (workerId > maxWorkerId || workerId < 0) {
exceptionCounter.incr(1)
throw new IllegalArgumentException("worker Id can't be greater than %d or less than 0".format(maxWorkerId))
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
exceptionCounter.incr(1)
throw new IllegalArgumentException("datacenter Id can't be greater than %d or less than 0".format(maxDatacenterId))
}
log.info("worker starting. timestamp left shift %d, datacenter id bits %d, worker id bits %d, sequence bits %d, workerid %d",
timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId)
def get_id(useragent: String): Long = {
if (!validUseragent(useragent)) {
exceptionCounter.incr(1)
throw new InvalidUserAgentError
}
val id = nextId()
genCounter(useragent)
reporter.report(new AuditLogEntry(id, useragent, rand.nextLong))
id
}
def get_worker_id(): Long = workerId
def get_datacenter_id(): Long = datacenterId
def get_timestamp() = System.currentTimeMillis
protected[snowflake] def nextId(): Long = synchronized {
var timestamp = timeGen()
if (timestamp < lastTimestamp) {
exceptionCounter.incr(1)
log.error("clock is moving backwards. Rejecting requests until %d.", lastTimestamp);
throw new InvalidSystemClock("Clock moved backwards. Refusing to generate id for %d milliseconds".format(
lastTimestamp - timestamp))
}
if (lastTimestamp == timestamp) {
sequence = (sequence + 1) & sequenceMask
if (sequence == 0) {
timestamp = tilNextMillis(lastTimestamp)
}
} else {
sequence = 0
}
lastTimestamp = timestamp
((timestamp - twepoch) << timestampLeftShift) |
(datacenterId << datacenterIdShift) |
(workerId << workerIdShift) |
sequence
}
protected def tilNextMillis(lastTimestamp: Long): Long = {
var timestamp = timeGen()
while (timestamp <= lastTimestamp) {
timestamp = timeGen()
}
timestamp
}
protected def timeGen(): Long = System.currentTimeMillis()
val AgentParser = """([a-zA-Z][a-zA-Z\-0-9]*)""".r
def validUseragent(useragent: String): Boolean = useragent match {
case AgentParser(_) => true
case _ => false
}
}
java版：
/**
* Twitter_Snowflake<br>
* 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每秒可以產生26萬ID左右。
*/
public class SnowflakeIdWorker {
// ==============================Fields===========================================
/** 開始時間截 (2015-01-01) */
private final long twepoch = 1420041600000L;
/** 機器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);
}
}
}
理解：
sequence = (sequence + 1) & sequenceMask;
private long maxWorkerId = -1L ^ (-1L << workerIdBits);
return ((timestamp - twepoch) << timestampLeftShift) |
(datacenterId << datacenterIdShift) |
(workerId << workerIdShift) |
sequence;
負數的二進制表示
在計算機中，負數的二進制是用補碼來表示的。
假設我是用Java中的int類型來存儲數字的，
int類型的大小是32個二進制位（bit），即4個字節（byte）。（1 byte = 8 bit）
那麼十進制數字3在二進制中的表示應該是這樣的：
00000000 00000000 00000000 00000011 // 3的二進制表示，就是原碼
那數字-3在二進制中應該如何表示？
咱們能夠反過來想一想，由於-3+3=0，
在二進制運算中把-3的二進制當作未知數x來求解，
求解算式的二進制表示以下：
00000000 00000000 00000000 00000011 //3，原碼 + xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx //-3，補碼 ----------------------------------------------- 00000000 00000000 00000000 00000000
反推x的值，3的二進制加上什麼值才使結果變成00000000 00000000 00000000 00000000？：
00000000 00000000 00000000 00000011 //3，原碼 + 11111111 11111111 11111111 11111101 //-3，補碼 ----------------------------------------------- 1 00000000 00000000 00000000 00000000
反推的思路是3的二進制數從最低位開始逐位加1，使溢出的1不斷向高位溢出，直到溢出到第33位。而後因爲int類型最多隻能保存32個二進制位，因此最高位的1溢出了，剩下的32位就成了（十進制的）0。
補碼的意義就是能夠拿補碼和原碼（3的二進制）相加，最終加出一個「溢出的0」
以上是理解的過程，實際中記住公式就很容易算出來：
- 補碼 = 反碼 + 1
- 補碼 = （原碼 - 1）再取反碼
所以-1的二進制應該這樣算：
00000000 00000000 00000000 00000001 //原碼：1的二進制 11111111 11111111 11111111 11111110 //取反碼：1的二進制的反碼 11111111 11111111 11111111 11111111 //加1：-1的二進制表示（補碼）
用位運算計算n個bit能表示的最大數值
好比這樣一行代碼：
private long workerIdBits = 5L;
private long maxWorkerId = -1L ^ (-1L << workerIdBits);
上面代碼換成這樣看方便一點：long maxWorkerId = -1L ^ (-1L << 5L)
-1 左移 5，得結果a ：
11111111 11111111 11111111 11111111 //-1的二進制表示（補碼）
11111 11111111 11111111 11111111 11100000 //高位溢出的不要，低位補0
11111111 11111111 11111111 11100000 //結果a
-1 異或 a ：
11111111 11111111 11111111 11111111 //-1的二進制表示（補碼）
^ 11111111 11111111 11111111 11100000 //兩個操做數的位中，相同則爲0，不一樣則爲1
---------------------------------------------------------------------------
00000000 00000000 00000000 00011111 //最終結果31
最終結果是31，二進制00000000 00000000 00000000 00011111轉十進制能夠這麼算：
那既然如今知道算出來long maxWorkerId = -1L ^ (-1L << 5L)中的maxWorkerId = 31，有什麼含義？爲何要用左移5來算？若是你看過概述部分，請找到這段內容看看：
5位（bit）能夠表示的最大正整數是2^5−1=31，便可以用0、一、二、三、....31這32個數字，來表示不一樣的datecenterId或workerId
-1L ^ (-1L << 5L)結果是31，2^5−1的結果也是31，因此在代碼中，-1L ^ (-1L << 5L)的寫法是利用位運算計算出5位能表示的最大正整數是多少
用mask防止溢出
有一段有趣的代碼：
sequence = (sequence + 1) & sequenceMask;
long seqMask = -1L ^ (-1L << 12L); //計算12位能耐存儲的最大正整數，至關於：2^12-1 = 4095
System.out.println("seqMask: "+seqMask);
System.out.println(1L & seqMask);
System.out.println(2L & seqMask);
System.out.println(3L & seqMask);
System.out.println(4L & seqMask);
System.out.println(4095L & seqMask);
System.out.println(4096L & seqMask);
System.out.println(4097L & seqMask);
System.out.println(4098L & seqMask);
/**
seqMask: 4095
1
2
3
4
4095
0
1
2
*/
這段代碼經過位與運算保證計算的結果範圍始終是 0-4095 ！
用位運算彙總結果
還有另一段詭異的代碼：
return ((timestamp - twepoch) << timestampLeftShift) |
(datacenterId << datacenterIdShift) |
(workerId << workerIdShift) |
sequence;
爲了弄清楚這段代碼，
首先 須要計算一下相關的值：
private long twepoch = 1288834974657L; //起始時間戳，用於用當前時間戳減去這個時間戳，算出偏移量
private long workerIdBits = 5L; //workerId佔用的位數：5
private long datacenterIdBits = 5L; //datacenterId佔用的位數：5
private long maxWorkerId = -1L ^ (-1L << workerIdBits); // workerId可使用的最大數值：31
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // datacenterId可使用的最大數值：31
private long sequenceBits = 12L;//序列號佔用的位數：12
private long workerIdShift = sequenceBits; // 12
private long datacenterIdShift = sequenceBits + workerIdBits; // 12+5 = 17
private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; // 12+5+5 = 22
private long sequenceMask = -1L ^ (-1L << sequenceBits);//4095
private long lastTimestamp = -1L;
其次 寫個測試，把參數都寫死，並運行打印信息，方便後面來覈對計算結果：
//---------------測試---------------
public static void main(String[] args) {
long timestamp = 1505914988849L;
long twepoch = 1288834974657L;
long datacenterId = 17L;
long workerId = 25L;
long sequence = 0L;
System.out.printf("\ntimestamp: %d \n",timestamp);
System.out.printf("twepoch: %d \n",twepoch);
System.out.printf("datacenterId: %d \n",datacenterId);
System.out.printf("workerId: %d \n",workerId);
System.out.printf("sequence: %d \n",sequence);
System.out.println();
System.out.printf("(timestamp - twepoch): %d \n",(timestamp - twepoch));
System.out.printf("((timestamp - twepoch) << 22L): %d \n",((timestamp - twepoch) << 22L));
System.out.printf("(datacenterId << 17L): %d \n" ,(datacenterId << 17L));
System.out.printf("(workerId << 12L): %d \n",(workerId << 12L));
System.out.printf("sequence: %d \n",sequence);
long result = ((timestamp - twepoch) << 22L) |
(datacenterId << 17L) |
(workerId << 12L) |
sequence;
System.out.println(result);
}
/** 打印信息：
timestamp: 1505914988849
twepoch: 1288834974657
datacenterId: 17
workerId: 25
sequence: 0
(timestamp - twepoch): 217080014192
((timestamp - twepoch) << 22L): 910499571845562368
(datacenterId << 17L): 2228224
(workerId << 12L): 102400
sequence: 0
910499571847892992
*/
代入位移的值得以後，就是這樣：
return ((timestamp - 1288834974657) << 22) |
(datacenterId << 17) |
(workerId << 12) |
sequence;
對於還沒有知道的值，咱們能夠先看看概述 中對SnowFlake結構的解釋，再代入在合法範圍的值(windows系統能夠用計算器方便計算這些值的二進制)，來了解計算的過程。
固然，因爲個人測試代碼已經把這些值寫死了，那直接用這些值來手工驗證計算結果便可：
long timestamp = 1505914988849L;
long twepoch = 1288834974657L;
long datacenterId = 17L;
long workerId = 25L;
long sequence = 0L;
設：timestamp = 1505914988849，twepoch = 1288834974657
1505914988849 - 1288834974657 = 217080014192 (timestamp相對於起始時間的毫秒偏移量)，其(a)二進制左移22位計算過程以下：
|<--這裏開始左右22位
00000000 00000000 000000|00 00110010 10001010 11111010 00100101 01110000 // a = 217080014192
00001100 10100010 10111110 10001001 01011100 00|000000 00000000 00000000 // a左移22位後的值(la)
|<--這裏後面的位補0
設：datacenterId = 17，其（b）二進制左移17位計算過程以下：
|<--這裏開始左移17位
00000000 00000000 0|0000000 00000000 00000000 00000000 00000000 00010001 // b = 17
00000000 00000000 00000000 00000000 00000000 0010001|0 00000000 00000000 // b左移17位後的值(lb)
|<--這裏後面的位補0
設：workerId = 25，其（c）二進制左移12位計算過程以下：
|<--這裏開始左移12位
00000000 0000|0000 00000000 00000000 00000000 00000000 00000000 00011001 // c = 25
00000000 00000000 00000000 00000000 00000000 00000001 1001|0000 00000000 // c左移12位後的值(lc)
|<--這裏後面的位補0
設：sequence = 0，其二進制以下： 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 // sequence = 0
如今知道了每一個部分左移後的值(la,lb,lc)，代碼能夠簡化成下面這樣去理解：
return ((timestamp - 1288834974657) << 22) |
(datacenterId << 17) |
(workerId << 12) |
sequence;
-----------------------------
|
|簡化
\|/
-----------------------------
return (la) |
(lb) |
(lc) |
sequence;
上面的管道符號|在Java中也是一個位運算符。其含義是：x的第n位和y的第n位 只要有一個是1，則結果的第n位也爲1，不然爲0，所以，咱們對四個數的位或運算以下：
1 | 41 | 5 | 5 | 12
0|0001100 10100010 10111110 10001001 01011100 00|00000|0 0000|0000 00000000 //la
0|0000000 00000000 00000000 00000000 00000000 00|10001|0 0000|0000 00000000 //lb
0|0000000 00000000 00000000 00000000 00000000 00|00000|1 1001|0000 00000000 //lc
or 0|0000000 00000000 00000000 00000000 00000000 00|00000|0 0000|0000 00000000 //sequence
------------------------------------------------------------------------------------------
0|0001100 10100010 10111110 10001001 01011100 00|10001|1 1001|0000 00000000 //結果：910499571847892992
結果計算過程：
1) 從至左列出1出現的下標（從0開始算）：
0000 1 1 00 1 0 1 000 1 0 1 0 1 1 1 1 1 0 1 000 1 00 1 0 1 0 1 1 1 0000 1 000 1 1 1 00 1 0000 0000 0000
59 58 55 53 49 47 45 44 43 42 41 39 35 32 30 28 27 26 21 17 16 15 12
2) 各個下標做爲2的冪數來計算，並相加：
2^59} : 576460752303423488
2^58} : 288230376151711744
2^55} : 36028797018963968
2^53} : 9007199254740992
2^49} : 562949953421312
2^47} : 140737488355328
2^45} : 35184372088832
2^44} : 17592186044416
2^43} : 8796093022208
2^42} : 4398046511104
2^41} : 2199023255552
2^39} : 549755813888
2^35} : 34359738368
2^32} : 4294967296
2^30} : 1073741824
2^28} : 268435456
2^27} : 134217728
2^26} : 67108864
2^21} : 2097152
2^17} : 131072
2^16} : 65536
2^15} : 32768
+ 2^12} : 4096
----------------------------------------
910499571847892992
觀察
1 | 41 | 5 | 5 | 12
0|0001100 10100010 10111110 10001001 01011100 00| | | //la
0| |10001| | //lb
0| | |1 1001| //lc
or 0| | | |0000 00000000 //sequence
------------------------------------------------------------------------------------------
0|0001100 10100010 10111110 10001001 01011100 00|10001|1 1001|0000 00000000 //結果：910499571847892992
上面的64位我按一、4一、五、五、12的位數截開了，方便觀察。
-
縱向觀察發現:- 在41位那一段，除了la一行有值，其它行（lb、lc、sequence）都是0，（我爸其它）
- 在左起第一個5位那一段，除了lb一行有值，其它行都是0
- 在左起第二個5位那一段，除了lc一行有值，其它行都是0
- 按照這規律，若是sequence是0之外的其它值，12位那段也會有值的，其它行都是0
-
橫向觀察發現:- 在la行，因爲左移了5+5+12位，五、五、12這三段都補0了，因此la行除了41那段外，其它確定都是0
- 同理，lb、lc、sequnece行也以此類推
- 正由於左移的操做，使四個不一樣的值移到了SnowFlake理論上相應的位置，而後四行作
位或運算（只要有1結果就是1），就把4段的二進制數合併成一個二進制數。
結論：
因此，在這段代碼中
return ((timestamp - 1288834974657) << 22) |
(datacenterId << 17) |
(workerId << 12) |
sequence;
左移運算是爲了將數值移動到對應的段(4一、五、5，12那段由於原本就在最右，所以不用左移)。 而後對每一個左移後的值(la、lb、lc、sequence)作位或運算，是爲了把各個短的數據合併起來，合併成一個二進制數。 最後轉換成10進制，就是最終生成的id
擴展
相關文章
- 1. 分佈式 ID 生成算法 -- Snowflake
- 2. Snowflake分佈式ID生成算法PHP的版本
- 3. snowflake 分佈式惟一ID生成器
- 4. 理解分佈式id生成算法SnowFlake
- 5. 分佈式ID生成方案（二）：SnowFlake雪花算法
- 6. 分佈式id之雪花算法 -- SnowFlake
- 7. 分佈式惟一 ID 之 Snowflake 算法
- 8. C# 實現 Snowflake算法 ID生成
- 9. snowflake分佈式惟一id
- 更多相關文章...
- • Eclipse 生成jar包 - Eclipse 教程
- • IP地址的格式和分類 - TCP/IP教程
- • 常用的分佈式事務解決方案
- • 算法總結-二分查找法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
歡迎關注本站公眾號,獲取更多信息
