全局唯一性ID生成方法小結

全局ID通常要滿足分片的一些要求：
1 不能有單點故障。
2 以時間為序，或者ID里包含時間。這樣一是可以少一個索引，二是冷熱數據容易分離。
3 可以控制ShardingId。比如某一個用戶的文章要放在同一個分片內，這樣查詢效率高，修改也容易。
4 不要太長，最好64bit。使用long比較好操作，如果是96bit，那就要各種移位相當的不方便，還有可能有些組件不能支持這么大的ID。

一、UUID

UUID生成的是length=32的16進制格式的字符串，如果回退為byte數組共16個byte元素，即UUID是一個128bit長的數字，
一般用16進制表示。
算法的核心思想是結合機器的網卡、當地時間、一個隨即數來生成UUID。
從理論上講，如果一台機器每秒產生10000000個GUID，則可以保證（概率意義上）3240年不重復
優點：
（1）本地生成ID，不需要進行遠程調用，時延低
（2）擴展性好，基本可以認為沒有性能上限
缺點：
（1）無法保證趨勢遞增
（2）uuid過長，往往用字符串表示，作為主鍵建立索引查詢效率低，常見優化方案為“轉化為兩個uint64整數存儲”或者“折半存儲”（折半后不能保證唯一性）

二、基於redis的分布式ID生成器

原理
利用redis的lua腳本執行功能，在每個節點上通過lua腳本生成唯一ID。
生成的ID是64位的：
使用41 bit來存放時間，精確到毫秒，可以使用41年。
使用12 bit來存放邏輯分片ID，最大分片ID是4095
使用10 bit來存放自增長ID，意味着每個節點，每毫秒最多可以生成1024個ID
比如GTM時間 Fri Mar 13 10:00:00 CST 2015 ，它的距1970年的毫秒數是 1426212000000，假定分片ID是53，自增長序列是4，則生成的ID是：
5981966696448054276 = 1426212000000 << 22 + 53 << 10 + 41
redis提供了TIME命令，可以取得redis服務器上的秒數和微秒數。因些lua腳本返回的是一個四元組。
second, microSecond, partition, seq
客戶端要自己處理，生成最終ID。
((second * 1000 + microSecond / 1000) << (12 + 10)) + (shardId << 10) + seq;

三、MongoDB文檔（Document）全局唯一ID

為了考慮分布式，“_id”要求不同的機器都能用全局唯一的同種方法方便的生成它。因此不能使用自增主鍵（需要多台服務器進行同步，既費時又費力），
因此選用了生成ObjectId對象的方法。

ObjectId使用12字節的存儲空間，其生成方式如下：
|0|1|2|3|4|5|6 |7|8|9|10|11|
|時間戳 |機器ID|PID|計數器 |

前四個字節時間戳是從標准紀元開始的時間戳，單位為秒，有如下特性：
1）時間戳與后邊5個字節一塊，保證秒級別的唯一性；
2）保證插入順序大致按時間排序；
3）隱含了文檔創建時間；
4）時間戳的實際值並不重要，不需要對服務器之間的時間進行同步（因為加上機器ID和進程ID已保證此值唯一，唯一性是ObjectId的最終訴求）。
機器ID是服務器主機標識，通常是機器主機名的散列值。
同一台機器上可以運行多個mongod實例，因此也需要加入進程標識符PID。
前9個字節保證了同一秒鍾不同機器不同進程產生的ObjectId的唯一性。后三個字節是一個自動增加的計數器（一個mongod進程需要一個全局的計數器），保證同一秒的ObjectId是唯一的。同一秒鍾最多允許每個進程擁有（256^3 = 16777216）個不同的ObjectId。

總結一下：時間戳保證秒級唯一，機器ID保證設計時考慮分布式，避免時鍾同步，PID保證同一台服務器運行多個mongod實例時的唯一性，最后的計數器保證同一秒內的唯一性（選用幾個字節既要考慮存儲的經濟性，也要考慮並發性能的上限）。
"_id"既可以在服務器端生成也可以在客戶端生成，在客戶端生成可以降低服務器端的壓力。

四、自定義32位GUID

原理：14位的當前系統時間(格式為：yyyyMMddHHmmss) + 當前電腦的IP地址的最后兩位 + 當前線程的hashCode的前9位 + 7位的隨機數

/**
 * GUID構造器
 * 32位：14位當前系統時間(yyyyMMddHHmmss) + 當前電腦的IP地址的最后兩位 + 當前線程的hashCode的前9位 + 7位的隨機數
 * 19位：12位當前系統時間(yyMMddHHmmss) + 當前線程的hashCode的前3位 + 4位的隨機數
 * @author Administrator
 * @create 2018-03-17 14:35
 */
public class UniqId {
    private static UniqId me = new UniqId();
    private String hostAddr;
    private final Random random = new SecureRandom();
    private final UniqTimer timer = new UniqTimer();

    private boolean isOutputInfo = false;

    private UniqId() {
        try {
            final InetAddress addr = InetAddress.getLocalHost();
            hostAddr = addr.getHostAddress();
        }catch (final IOException e) {
            System.err.println("[UniqID] Get HostAddr Error"+e);
            hostAddr = String.valueOf(System.currentTimeMillis());
        }
        if (null == hostAddr || hostAddr.trim().length() == 0 || "127.0.0.1".equals(hostAddr)) {
            hostAddr = String.valueOf(System.currentTimeMillis());
        }
        hostAddr = hostAddr.substring(hostAddr.length()-2).replace(".", "0");
        if(isOutputInfo){
            System.out.println("[UniqID]hostAddr is:" + hostAddr + "----length:"+hostAddr.length());
        }
    }


    /**
     * 獲取UniqID實例
     * @return UniqId
     */
    public static UniqId getInstance() {
        me.isOutputInfo = false;
        return me;
    }

    /**
     * 獲取UniqID實例
     * @return UniqId
     */
    public static UniqId getInstanceWithLog() {
        me.isOutputInfo = true;
        return me;
    }


    /**
     * 獲得不會重復的毫秒數
     *
     * @return 不會重復的時間
     */
    public String getUniqTime() {
        String time = timer.getCurrentTime();
        if(isOutputInfo){
            System.out.println("[UniqID.getUniqTime]" + time +"----length:"+ time.length());
        }
        return time;
    }

    public String getUniqTime2() {
        String time = timer.getCurrentTime2();
        if(isOutputInfo){
            System.out.println("[UniqID.getUniqTime]" + time +"----length:"+ time.length());
        }
        return time;
    }

    /**
     * 獲得UniqId
     *
     * @return uniqTime-randomNum-hostAddr-threadId
     */
    public String get32UniqID() {
        final StringBuffer sb = new StringBuffer();
        final String t = getUniqTime();
        int randomNumber = random.nextInt(8999999) + 1000000;
        sb.append(t);
        sb.append(hostAddr);
        sb.append(getUniqThreadCode());
        sb.append(randomNumber);
        if (isOutputInfo) {
            System.out.println("[UniqID.randomNumber]" + randomNumber+"----length:"+String.valueOf(randomNumber).length());
            System.out.println("[UniqID.getUniqID]" + sb.toString()+"----length:"+String.valueOf(sb).length());
        }
        return sb.toString();
    }

    /**
     * 獲取19位GUID 不考慮分布式
     * @return
     */
    public Long get19UniqID() {
        final StringBuffer sb = new StringBuffer();
        final String t = getUniqTime2();
        int randomNumber = random.nextInt(8999) + 1000;
        sb.append(t);
        sb.append(getUniqThreadCode2());
        sb.append(randomNumber);
        return Long.parseLong(sb.toString());
    }

    public String getUniqThreadCode(){
        String threadCode = StringUtils.left(String.valueOf(Thread.currentThread().hashCode()),9);
        if (isOutputInfo) {
            System.out.println("[UniqID.getUniqThreadCode]" +threadCode+"----length:"+threadCode.length());
        }
        return StringUtils.leftPad(threadCode, 9, "0");
    }

    public String getUniqThreadCode2(){
        String threadCode = StringUtils.left(String.valueOf(Thread.currentThread().hashCode()),9);
        if (isOutputInfo) {
            System.out.println("[UniqID.getUniqThreadCode]" +threadCode+"----length:"+threadCode.length());
        }
        return StringUtils.leftPad(threadCode, 9, "0").substring(6);
    }

    /**
     * 實現不重復的時間
     */
    private class UniqTimer {
        private final AtomicLong lastTime = new AtomicLong(System.currentTimeMillis());
        public String getCurrentTime() {
            if(!timestamp2Date(this.lastTime.incrementAndGet()).equals(timestamp2Date(System.currentTimeMillis()))){
                lastTime.set(System.currentTimeMillis()+random.nextInt(10000));
            }
            return timestamp2Datetimes(this.lastTime.incrementAndGet());
        }

        public String getCurrentTime2() {
            if(!timestamp2Date(this.lastTime.incrementAndGet()).equals(timestamp2Date(System.currentTimeMillis()))){
                lastTime.set(System.currentTimeMillis()+random.nextInt(10000));
            }
            return timestamp2Datetimes2(this.lastTime.incrementAndGet());
        }
    }

    /**
     * 規范化日期，規范成yyyy-MM-dd
     * @param timestamp
     * @return
     */
    public static String timestamp2Date(long timestamp){
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return dateFormat.format(new Date(timestamp * 1000));
    }

    private static String timestamp2Datetimes(long timestamp){
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        return dateFormat.format(new Date(timestamp));
    }

    private static String timestamp2Datetimes2(long timestamp){
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMddHHmmss");
        return dateFormat.format(new Date(timestamp));
    }

}