前言

　　這個問題源自於，我想找一個分散式下的ID生成器。
　　這個最簡單的方案是，資料庫自增ID。為啥不用咧？有這麼幾點原因，一是，會依賴於資料庫的具體實現，比如，mysql有自增，oracle沒有，得用序列，mongo似乎也沒有他自己有個什麼ID，sqlserver貌似有自增等等，有些不穩定因素，因為ID生成是業務的核心基礎。當然，還有就是效能，自增ID是連續的，它就依賴於資料庫自身的鎖，所以資料庫就有瓶頸。當然了，多臺資料庫加某種間隔也是可用的，但是，運維維護會很複雜，因為它不是內聚的解決方案。而且，很難提前獲得下一個ID。
　　後來，我用過一段時間在資料庫表裡進行記錄來進行自增。這個的優勢是，我可以提前獲得下一個ID，而且，某個程序裡可以一次獲取一批，減少鎖的依賴，雖然程序間的不重複依然是基於資料庫事務隔離的，但是，依賴小了，瓶頸小了。這個方案其實挺好的，我依然也會繼續用，主要是，它可以生成數字字母混合的編劇號，而且基本可控。但是，我資料庫主鍵為了效率和空間成本，基本會選用long，基本順序生成就可以了，所以，使用這種帶持久化的方案，會顯得很重。起專案的時候，也是，需要先建立對應的表，然後再把程式碼或者jar包引進去，然後再用，比較重。最好就是能夠直接生成，沒有那麼多依賴。
　　然後，我從我上司那裡聽到了twitter的這個演算法。其實，我上司有個實現，我這個就是基於他的改的，但是，他的有兩個值是配置的，我還是嫌麻煩，於是就動手把那兩個值變成了從機器與程序獲取，就有了這個版本。

思路

　　說實話，我也就聽了這麼個演算法的名字，沒正經看過原演算法，但是，我上司說他程式碼是網上抄的，所以，這個演算法名字我還是不敢丟，下面我們說說整體的思路。
　　整個ID的構成大概分為這麼幾個部分，時間戳差值，機器編碼，程序編碼，序列號。java的long是64位的從左向右依次介紹是：時間戳差值，在我們這裡佔了42位；機器編碼5位；程序編碼5位；序列號12位。所有的拼接用位運算拼接起來，於是就基本做到了每個程序中不會重複了。

程式碼

package nature.framework.core.common;

import java.lang.management.ManagementFactory;
import
 
 java.lang.management.RuntimeMXBean;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;

/**
 * 主鍵生成器
 *
 * @author nature
 * @create 2017-12-22 10:58
 */
public class KeyWorker {
    private final static long twepoch = 12888349746579L;
    // 機器標識位數
    private
 
 final static long workerIdBits = 5L;
    // 資料中心標識位數
    private final static long datacenterIdBits = 5L;

    // 毫秒內自增位數
    private final static long sequenceBits = 12L;
    // 機器ID偏左移12位
    private final static long workerIdShift = sequenceBits;
    // 資料中心ID左移17位
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    // 時間毫秒左移22位
    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    //sequence掩碼，確保sequnce不會超出上限
    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    //上次時間戳
    private static long lastTimestamp = -1L;
    //序列
    private long sequence = 0L;
    //伺服器ID
    private long workerId = 1L;
    private static long workerMask= -1L ^ (-1L << workerIdBits);
    //程序編碼
    private long processId = 1L;
    private static long processMask=-1L ^ (-1L << datacenterIdBits);
    private static KeyWorker keyWorker = null;

    static{
        keyWorker=new KeyWorker();
    }
    public static synchronized long nextId(){
        return keyWorker.getNextId();
    }

    private KeyWorker() {

        //獲取機器編碼
        this.workerId=this.getMachineNum();
        //獲取程序編碼
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        this.processId=Long.valueOf(runtimeMXBean.getName().split("@")[0]).longValue();

        //避免編碼超出最大值
        this.workerId=workerId & workerMask;
        this.processId=processId & processMask;
    }

    public synchronized long getNextId() {
        //獲取時間戳
        long timestamp = timeGen();
        //如果時間戳小於上次時間戳則報錯
        if (timestamp < lastTimestamp) {
            try {
                throw new Exception("Clock moved backwards.  Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //如果時間戳與上次時間戳相同
        if (lastTimestamp == timestamp) {
            // 當前毫秒內，則+1，與sequenceMask確保sequence不會超出上限
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 當前毫秒內計數滿了，則等待下一秒
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0;
        }
        lastTimestamp = timestamp;
        // ID偏移組合生成最終的ID，並返回ID
        long nextId = ((timestamp - twepoch) << timestampLeftShift) | (processId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
        return nextId;
    }

    /**
     * 再次獲取時間戳直到獲取的時間戳與現有的不同
     * @param lastTimestamp
     * @return 下一個時間戳
     */
    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }

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

    /**
     * 獲取機器編碼
     * @return
     */
    private long getMachineNum(){
        long machinePiece;
        StringBuilder sb = new StringBuilder();
        Enumeration<NetworkInterface> e = null;
        try {
            e = NetworkInterface.getNetworkInterfaces();
        } catch (SocketException e1) {
            e1.printStackTrace();
        }
        while (e.hasMoreElements()) {
            NetworkInterface ni = e.nextElement();
            sb.append(ni.toString());
        }
        machinePiece = sb.toString().hashCode();
        return machinePiece;
    }
}

程式碼解讀

整體設計

　　為了最大程度的減少配置，方便實用，這個模組，我設計成了單例模式。之所以沒有直接使用static方法，還是希望可以控制整個模組的生命週期，但是，模組的初始化，我使用了static塊，因為它沒有任何依賴。
　　有個static的nextId方法，可以直接獲得下一個ID，這個方法是執行緒安全的。同時這個模組的使用就是這麼簡單粗暴，也不用配置bean。

ID生成邏輯

　　我們先看最後一步：long nextId = ((timestamp - twepoch) << timestampLeftShift) | (processId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
　　這句話什麼意思呢？
　　timestamp - twepoch：時間戳減去一個時間戳，獲得一個差值。
　　((timestamp - twepoch) << timestampLeftShift)：timestampLeftShift是22，這個操作是將這個差值向左移22位，左移空出來的會自動補0，我們就有了22位的空間了。
　　後面可以看到三個|符號，與操作會把1都加進來，而我們後面的數也都在各自的位上才有1，那麼|操作就把這些數合進來了。
　　(processId << datacenterIdShift)：程序編碼左移datacenterIdShift，這個是17位，而processId最多是5位，於是剛好填滿空位
　　(workerId << workerIdShift)：與程序編碼類似，機器編碼也是5位，左移12位
　　sequence最大12位。

如何確保不超出位數限制

　　前面的邏輯中，我們說了很多不超出位數限制啥的內容，那麼，具體是怎麼做到的呢？我們拿workerId舉個例子：
　　this.workerId=workerId & workerMask;
　　這是我們確保workerId不超過5位的語句，什麼意思呢？不經常操作位運算真看不懂。我們先看看workerMask是啥。
　　private static long workerMask= -1L ^ (-1L << workerIdBits);
　　。。。什麼意思呀？它先執行的是-1L << workerIdBits，workerIdBits是5。這又是什麼意思呢？注意，這是位運算，long用的是補碼，-1L，就是64個1，這裡使用-1是為了格式化所有位數，<<是左移運算，-1L左移五位，低位補零，也就是左移空出來的會自動補0，於是就低位五位是0，其餘是1。然後^這個符號，是異或，也是位運算，位上相同則為0，不通則為1，和-1做異或，則把所有的0和1顛倒了一下。這時候，我們再看，workerId & workerMask，與操作，兩個位上都為1的才能唯一，否則為零，workerMask高位都是0，所以，不管workerId高位是什麼，都是0,；而workerMask低位都是1，所以，不管workerId低位是什麼，都會被保留，於是，我們就控制了workerId的範圍。

最後的異常

　　這裡，時間戳，保證了不通毫秒不同，然後機器編碼程序編碼保證了不同程序不通，再然後，序列，在統一毫秒內，如果獲取第二個ID，則序列號+1，到下一毫秒後重置。至此，唯一性ok。但是，還有問題，序列號用完了怎麼辦？程式碼裡的解決方案是，等到下一毫秒。

補充

　　其實，這個方案中，機器碼和程序編碼是可能相同的，只是概率比較小，我們就湊合著用吧。如果有更好地獲取這兩位的方式，歡迎溝通。