• 數(shù)據(jù)庫自增id
• uuid
• 獲取系統(tǒng)當前時間
• snowflake算法
  當然還有其它的算法

數(shù)據(jù)庫自增id

這個就是說你的系統(tǒng)里每次得到一個id枉昏，都是往一個庫的一個表里插入一條沒什么業(yè)務含義的數(shù)據(jù)，然后獲取一個數(shù)據(jù)庫自增的一個id揍鸟。拿到這個id之后再往對應的分庫分表里去寫入兄裂。

這個方案的好處就是方便簡單，誰都會用阳藻；缺點就是單庫生成自增id晰奖，要是高并發(fā)的話，就會有瓶頸的腥泥；如果你硬是要改進一下匾南，那么就專門開一個服務出來，這個服務每次就拿到當前id最大值蛔外，然后自己遞增幾個id蛆楞，一次性返回一批id，然后再把當前最大id值修改成遞增幾個id之后的一個值夹厌；但是無論怎么說都是基于單個數(shù)據(jù)庫臊岸。

數(shù)據(jù)庫自增id.png

適合的場景：你分庫分表就倆原因，要不就是單庫并發(fā)太高尊流，要不就是單庫數(shù)據(jù)量太大；除非是你并發(fā)不高灯帮，但是數(shù)據(jù)量太大導致的分庫分表擴容崖技，你可以用這個方案，因為可能每秒最高并發(fā)最多就幾百钟哥，那么就走單獨的一個庫和表生成自增主鍵即可迎献。

并發(fā)很低，幾百/s腻贰，但是數(shù)據(jù)量大吁恍，幾十億的數(shù)據(jù)，所以需要靠分庫分表來存放海量的數(shù)據(jù)

uuid

好處就是本地生成播演，不要基于數(shù)據(jù)庫來了冀瓦；不好之處就是，uuid太長了写烤，作為主鍵性能太差了翼闽，不適合用于主鍵。

適合的場景：如果你是要隨機生成個什么文件名了洲炊，編號之類的感局，你可以用uuid尼啡，但是作為主鍵是不能用uuid的。

獲取系統(tǒng)當前時間

這個就是獲取當前時間即可询微，但是問題是崖瞭，并發(fā)很高的時候，比如一秒并發(fā)幾千撑毛，會有重復的情況书聚，這個是肯定不合適的〈基本就不用考慮了寺惫。

適合的場景：一般如果用這個方案，是將當前時間跟很多其他的業(yè)務字段拼接起來蹦疑，作為一個id西雀，如果業(yè)務上你覺得可以接受，那么也是可以的歉摧。你可以將別的業(yè)務字段值跟當前時間拼接起來艇肴，組成一個全局唯一的編號，訂單編號叁温，時間戳 + 用戶id + 業(yè)務含義編碼

snowflake算法

snowflake算法.png

twitter開源的分布式id生成算法再悼，就是把一個64位的long型的id，1個bit是不用的膝但，用其中的41 bit作為毫秒數(shù)冲九，用10 bit作為工作機器id，12 bit作為序列號（單機并發(fā)量）

1 bit：不用跟束，為啥呢莺奸？因為二進制里第一個bit為如果是1，那么都是負數(shù)冀宴，但是我們生成的id都是正數(shù)灭贷，所以第一個bit統(tǒng)一都是0

41 bit：表示的是時間戳，單位是毫秒略贮。41 bit可以表示的數(shù)字多達2^41 - 1甚疟，也就是可以標識2 ^ 41 - 1個毫秒值，換算成年就是表示69年的時間逃延。

10 bit：記錄工作機器id览妖，代表的是這個服務最多可以部署在2^10臺機器上哪，也就是1024臺機器揽祥。但是10 bit里5個bit代表機房id黄痪，5個bit代表機器id。意思就是最多代表2 ^ 5個機房（32個機房）盔然，每個機房里可以代表2 ^ 5個機器（32臺機器）桅打。

12 bit：這個是用來記錄同一個毫秒內(nèi)產(chǎn)生的不同id是嗜，12 bit可以代表的最大正整數(shù)是2 ^ 12 - 1 = 4096，也就是說可以用這個12bit代表的數(shù)字來區(qū)分同一個毫秒內(nèi)的4096個不同的id

64位的long型的id挺尾，64位的long -> 二進制

0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000000

2018-01-01 10:00:00 -> 做了一些計算鹅搪，再換算成一個二進制，41bit來放 -> 0001100 10100010 10111110 10001001 01011100 00

機房id遭铺，17 -> 換算成一個二進制 -> 10001

機器id丽柿，25 -> 換算成一個二進制 -> 11001

snowflake算法服務，會判斷一下魂挂，當前這個請求是否是甫题，機房17的機器25，在2175/11/7 12:12:14時間點發(fā)送過來的第一個請求涂召，如果是第一個請求

假設坠非，在2175/11/7 12:12:14時間里，機房17的機器25果正，發(fā)送了第二條消息炎码，snowflake算法服務，會發(fā)現(xiàn)說機房17的機器25秋泳，在2175/11/7 12:12:14時間里潦闲，在這一毫秒，之前已經(jīng)生成過一個id了迫皱，此時如果你同一個機房歉闰，同一個機器，在同一個毫秒內(nèi)卓起，再次要求生成一個id新娜，此時我只能把加1

0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000001

比如我們來觀察上面的那個，就是一個典型的二進制的64位的id既绩，換算成10進制就是910499571847892992。

public class IdWorker{
   //機器ID
    private long workerId;
   //機房ID
    private long datacenterId;
   //當前機器當前時間序列號
    private long sequence;

    public IdWorker(long workerId, long datacenterId, long sequence){
        // sanity check for workerId
// 這兒不就檢查了一下还惠，要求就是你傳遞進來的機房id和機器id不能超過32饲握，不能小于0
        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));
        }
        System.out.printf("worker starting. timestamp left shift %d, datacenter id bits %d, worker id bits %d, sequence bits %d, workerid %d",
                timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId);

        this.workerId = workerId;
        this.datacenterId = datacenterId;
        this.sequence = sequence;
    }

    private long twepoch = 1288834974657L;

    private long workerIdBits = 5L;
    private long datacenterIdBits = 5L;
    private long maxWorkerId = -1L ^ (-1L << workerIdBits); // 這個是二進制運算，就是5 bit最多只能有31個數(shù)字蚕键，也就是說機器id最多只能是32以內(nèi)
    private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 這個是一個意思救欧，就是5 bit最多只能有31個數(shù)字，機房id最多只能是32以內(nèi)
    private long sequenceBits = 12L;

    private long workerIdShift = sequenceBits;
    private long datacenterIdShift = sequenceBits + workerIdBits;
    private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    private long sequenceMask = -1L ^ (-1L << sequenceBits);

    private long lastTimestamp = -1L;

    public long getWorkerId(){
        return workerId;
    }

    public long getDatacenterId(){
        return datacenterId;
    }

    public long getTimestamp(){
        return System.currentTimeMillis();
    }

public synchronized long nextId() {
// 這兒就是獲取當前時間戳锣光，單位是毫秒
        long timestamp = timeGen();

        if (timestamp < lastTimestamp) {
            System.err.printf("clock is moving backwards.  Rejecting requests until %d.", lastTimestamp);
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds",
                    lastTimestamp - timestamp));
        }

// 0
// 在同一個毫秒內(nèi)笆怠，又發(fā)送了一個請求生成一個id，0 -> 1

        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask; // 這個意思是說一個毫秒內(nèi)最多只能有4096個數(shù)字誊爹，無論你傳遞多少進來蹬刷，這個位運算保證始終就是在4096這個范圍內(nèi)瓢捉，避免你自己傳遞個sequence超過了4096這個范圍
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0;
        }

// 這兒記錄一下最近一次生成id的時間戳，單位是毫秒
        lastTimestamp = timestamp;

// 這兒就是將時間戳左移办成，放到41 bit那兒泡态；將機房id左移放到5 bit那兒；將機器id左移放到5 bit那兒迂卢；將序號放最后10 bit某弦；最后拼接起來成一個64 bit的二進制數(shù)字，轉(zhuǎn)換成10進制就是個long型
        return ((timestamp - twepoch) << timestampLeftShift) |
                (datacenterId << datacenterIdShift) |
                (workerId << workerIdShift) |
                sequence;
    }

// 0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000000


    private long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

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

    //---------------測試---------------
    public static void main(String[] args) {
        IdWorker worker = new IdWorker(1,1,1);
        for (int i = 0; i < 30; i++) {
            System.out.println(worker.nextId());
        }
    }

}

怎么說呢而克，大概這個意思吧靶壮，就是說41 bit，就是當前毫秒單位的一個時間戳员萍，就這意思腾降；然后5 bit是你傳遞進來的一個機房id（但是最大只能是32以內(nèi)），5 bit是你傳遞進來的機器id（但是最大只能是32以內(nèi)）充活，剩下的那個10 bit序列號蜂莉，就是如果跟你上次生成id的時間還在一個毫秒內(nèi)，那么會把順序給你累加混卵，最多在4096個序號以內(nèi)映穗。

所以你自己利用這個工具類，自己搞一個服務幕随，然后對每個機房的每個機器都初始化這么一個東西蚁滋，剛開始這個機房的這個機器的序號就是0。然后每次接收到一個請求赘淮，說這個機房的這個機器要生成一個id辕录，你就找到對應的Worker，生成梢卸。

他這個算法生成的時候走诞，會把當前毫秒放到41 bit中，然后5 bit是機房id蛤高，5 bit是機器id蚣旱，接著就是判斷上一次生成id的時間如果跟這次不一樣，序號就自動從0開始戴陡；要是上次的時間跟現(xiàn)在還是在一個毫秒內(nèi)塞绿，他就把seq累加1，就是自動生成一個毫秒的不同的序號恤批。

這個算法那异吻，可以確保說每個機房每個機器每一毫秒，最多生成4096個不重復的id喜庞。

利用這個snowflake算法诀浪，你可以開發(fā)自己公司的服務棋返，甚至對于機房id和機器id，反正給你預留了5 bit + 5 bit笋妥，你換成別的有業(yè)務含義的東西也可以的懊昨。

這個snowflake算法相對來說還是比較靠譜的，所以你要真是搞分布式id生成春宣，如果是高并發(fā)啥的酵颁，那么用這個應該性能比較好，一般每秒幾萬并發(fā)的場景月帝，也足夠你用了躏惋。