一、用數(shù)據(jù)庫(kù)主鍵自增生成訂單ID

數(shù)據(jù)庫(kù)主鍵順序自增，每天有多少訂單量被競(jìng)爭(zhēng)對(duì)手看得一清二楚，商業(yè)機(jī)密都暴露了。 況且單機(jī)MySQL只能支持幾百量級(jí)的并發(fā)，如果系統(tǒng)每天千萬(wàn)訂單量，完全hold不住。

二、用數(shù)據(jù)庫(kù)集群

數(shù)據(jù)庫(kù)集群，自增ID起始值按機(jī)器編號(hào)，步長(zhǎng)等于機(jī)器數(shù)量。比如有兩臺(tái)機(jī)器，第一臺(tái)機(jī)器生成的ID是1、3、5、7，第二臺(tái)機(jī)器生成的ID是2、4、6、8。性能不行就加機(jī)器，這并發(fā)量一下就上去了。

但實(shí)現(xiàn)百萬(wàn)級(jí)的并發(fā)，大概就需要2000臺(tái)機(jī)器，這還只是用來(lái)生成訂單ID，公司再有錢(qián)也經(jīng)不起這么造。

三、號(hào)段模式

然MySQL的并發(fā)量不行，我們是不是可以提前從MySQL獲取一批自增ID，加載到本地內(nèi)存中，然后從內(nèi)存中并發(fā)取。這種叫號(hào)段模式。并發(fā)量是上去了，但是自增ID還是不能作為訂單ID的。

四、用Java自帶UUID

import java.util.UUID;

/**
 * @author yideng
 * @apiNote UUID示例
 */
public class UUIDTest {
    public static void main(String[] args) {
        String orderId = UUID.randomUUID().toString().replace("-", "");
        System.out.println(orderId);
    }
}

輸出結(jié)果：

58e93ecab9c64295b15f7f4661edcbc1

也不行。32位字符串會(huì)占用更大的空間，無(wú)序的字符串作數(shù)據(jù)庫(kù)主鍵，每次插入數(shù)據(jù)庫(kù)的時(shí)候，MySQL為了維護(hù)B+樹(shù)結(jié)構(gòu)，需要頻繁調(diào)整節(jié)點(diǎn)順序，影響性能。況且字符串太長(zhǎng)，也沒(méi)有任何業(yè)務(wù)含義，pass。

五、生成訂單ID要滿足的條件

• 全局唯一：如果訂單ID重復(fù)了，肯定要完蛋。

• 高性能：要做到高并發(fā)、低延遲。生成訂單ID都成為瓶頸了，那還得了。

• 高可用：至少要做到4個(gè)9，別動(dòng)不動(dòng)就宕機(jī)了。

• 易用性：如果為了滿足上述要求，搞了幾百臺(tái)服務(wù)器，復(fù)雜且難以維護(hù)，也不行。

• 數(shù)值且有序遞增：數(shù)值占用的空間更小，有序遞增能保證插入MySQL的時(shí)候更高性能。

• 嵌入業(yè)務(wù)含義：如果訂單ID里面能嵌入業(yè)務(wù)含義，就能通過(guò)訂單ID知道是哪個(gè)業(yè)務(wù)線生成的，便于排查問(wèn)題。

六、雪花算法生成訂單ID

一種流傳已久的分布式、高性能、高可用的訂單ID生成算法—雪花算法，完全能滿足你的上述要求。雪花算法生成ID是Long類型，長(zhǎng)度64位。

雪花算法

• 第 1 位： 符號(hào)位，暫時(shí)不用。
• 第 2~42 位：共41位，時(shí)間戳，單位是毫秒，可以支撐大約69年
• 第 43~52 位：共10位，機(jī)器ID，最多可容納1024臺(tái)機(jī)器
• 第 53~64 位：共12位，序列號(hào)，是自增值，表示同一毫秒內(nèi)產(chǎn)生的ID，單臺(tái)機(jī)器每毫秒最多可生成4096個(gè)訂單ID

代碼實(shí)現(xiàn)：

package com.ac.member.config.mybatis;

import com.baomidou.mybatisplus.core.toolkit.SystemClock;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.StringUtils;

import java.net.Inet4Address;
import java.net.UnknownHostException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;

@Slf4j
public class SnowFlake {

    /** 初始偏移時(shí)間戳 */
    private static final long OFFSET = 1546300800L;

    /** 機(jī)器id (0~15 保留 16~31作為備份機(jī)器) */
    private static final long WORKER_ID;
    /** 機(jī)器id所占位數(shù) (5bit, 支持最大機(jī)器數(shù) 2^5 = 32)*/
    private static final long WORKER_ID_BITS = 5L;
    /** 自增序列所占位數(shù) (16bit, 支持最大每秒生成 2^16 = 65536) */
    private static final long SEQUENCE_ID_BITS = 16L;
    /** 機(jī)器id偏移位數(shù) */
    private static final long WORKER_SHIFT_BITS = SEQUENCE_ID_BITS;
    /** 自增序列偏移位數(shù) */
    private static final long OFFSET_SHIFT_BITS = SEQUENCE_ID_BITS + WORKER_ID_BITS;
    /** 機(jī)器標(biāo)識(shí)最大值 (2^5 / 2 - 1 = 15) */
    private static final long WORKER_ID_MAX = ((1 << WORKER_ID_BITS) - 1) >> 1;
    /** 備份機(jī)器ID開(kāi)始位置 (2^5 / 2 = 16) */
    private static final long BACK_WORKER_ID_BEGIN = (1 << WORKER_ID_BITS) >> 1;
    /** 自增序列最大值 (2^16 - 1 = 65535) */
    private static final long SEQUENCE_MAX = (1 << SEQUENCE_ID_BITS) - 1;
    /** 發(fā)生時(shí)間回?fù)軙r(shí)容忍的最大回?fù)軙r(shí)間 (秒) */
    private static final long BACK_TIME_MAX = 1000L;

    /** 上次生成ID的時(shí)間戳 (秒) */
    private static long lastTimestamp = 0L;
    /** 當(dāng)前秒內(nèi)序列 (2^16)*/
    private static long sequence = 0L;
    /** 備份機(jī)器上次生成ID的時(shí)間戳 (秒) */
    private static long lastTimestampBak = 0L;
    /** 備份機(jī)器當(dāng)前秒內(nèi)序列 (2^16)*/
    private static long sequenceBak = 0L;

    static {
        // 初始化機(jī)器ID
        long workerId = getWorkId();
        if (workerId < 0 || workerId > WORKER_ID_MAX) {
            throw new IllegalArgumentException(String.format("cmallshop.workerId范圍: 0 ~ %d 目前: %d", WORKER_ID_MAX, workerId));
        }
        WORKER_ID = workerId;
    }

    private static Long getWorkId(){
        try {
            String hostAddress = Inet4Address.getLocalHost().getHostAddress();
            int[] ints = StringUtils.toCodePoints(hostAddress);
            int sums = 0;
            for(int b : ints){
                sums += b;
            }
            return (long)(sums % WORKER_ID_MAX);
        } catch (UnknownHostException e) {
            // 如果獲取失敗，則使用隨機(jī)數(shù)備用
            return RandomUtils.nextLong(0,WORKER_ID_MAX-1);
        }
    }


    /** 私有構(gòu)造函數(shù)禁止外部訪問(wèn) */
    private SnowFlake() {}

    /**
     * 獲取自增序列
     * @return long
     */
    public static long nextId() {
        return nextId(SystemClock.now() / 1000);
    }

    /**
     * 主機(jī)器自增序列
     * @param timestamp 當(dāng)前Unix時(shí)間戳
     * @return long
     */
    private static synchronized long nextId(long timestamp) {
        // 時(shí)鐘回?fù)軝z查
        if (timestamp < lastTimestamp) {
            // 發(fā)生時(shí)鐘回?fù)?            log.warn("時(shí)鐘回?fù)? 啟用備份機(jī)器ID: now: [{}] last: [{}]", timestamp, lastTimestamp);
            return nextIdBackup(timestamp);
        }

        // 開(kāi)始下一秒
        if (timestamp != lastTimestamp) {
            lastTimestamp = timestamp;
            sequence = 0L;
        }
        if (0L == (++sequence & SEQUENCE_MAX)) {
            // 秒內(nèi)序列用盡
//            log.warn("秒內(nèi)[{}]序列用盡, 啟用備份機(jī)器ID序列", timestamp);
            sequence--;
            return nextIdBackup(timestamp);
        }

        return ((timestamp - OFFSET) << OFFSET_SHIFT_BITS) | (WORKER_ID << WORKER_SHIFT_BITS) | sequence;
    }

    /**
     * 備份機(jī)器自增序列
     * @param timestamp timestamp 當(dāng)前Unix時(shí)間戳
     * @return long
     */
    private static long nextIdBackup(long timestamp) {
        if (timestamp < lastTimestampBak) {
            if (lastTimestampBak - SystemClock.now() / 1000 <= BACK_TIME_MAX) {
                timestamp = lastTimestampBak;
            } else {
                throw new RuntimeException(String.format("時(shí)鐘回?fù)? now: [%d] last: [%d]", timestamp, lastTimestampBak));
            }
        }

        if (timestamp != lastTimestampBak) {
            lastTimestampBak = timestamp;
            sequenceBak = 0L;
        }

        if (0L == (++sequenceBak & SEQUENCE_MAX)) {
            // 秒內(nèi)序列用盡
//            logger.warn("秒內(nèi)[{}]序列用盡, 備份機(jī)器ID借取下一秒序列", timestamp);
            return nextIdBackup(timestamp + 1);
        }

        return ((timestamp - OFFSET) << OFFSET_SHIFT_BITS) | ((WORKER_ID ^ BACK_WORKER_ID_BEGIN) << WORKER_SHIFT_BITS) | sequenceBak;
    }


    /**
     * 并發(fā)數(shù)
     */
    private static final int THREAD_NUM = 30000;
    private static volatile CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM);

    public static void main(String[] args) {
        ConcurrentHashMap<Long,Long> map = new ConcurrentHashMap<>(THREAD_NUM);
        List<Long> list = Collections.synchronizedList(new LinkedList<>());

        for (int i = 0; i < THREAD_NUM; i++) {
            Thread thread = new Thread(() -> {
                // 所有的線程在這里等待
                try {
                    countDownLatch.await();

                    Long id = SnowFlake.nextId();
                    list.add(id);
                    map.put(id,1L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });

            thread.start();
            // 啟動(dòng)后，倒計(jì)時(shí)計(jì)數(shù)器減一，代表有一個(gè)線程準(zhǔn)備就緒了
            countDownLatch.countDown();
        }

        try{
            Thread.sleep(50000);
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("listSize:"+list.size());
        System.out.println("mapSize:"+map.size());
        System.out.println(map.size() == THREAD_NUM);
    }
}

與mybatis-plus結(jié)合

import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class CustomIdGenerator implements IdentifierGenerator {
    
    @Override
    public Long nextId(Object entity) {
        return SnowFlake.nextId();
    }
}

接入非常簡(jiǎn)單，不需要搭建服務(wù)集群。代碼邏輯非常簡(jiǎn)單，同一毫秒內(nèi)，訂單ID的序列號(hào)自增。同步鎖只作用于本機(jī)，機(jī)器之間互不影響，每毫秒可以4百萬(wàn)的訂單ID，非常強(qiáng)悍。

生成規(guī)則不是固定的，可以根據(jù)自身的業(yè)務(wù)需求調(diào)整。如果你不需要那么大的并發(fā)量，可以把機(jī)器標(biāo)識(shí)位拆出一部分，當(dāng)作業(yè)務(wù)標(biāo)識(shí)位，標(biāo)識(shí)是哪個(gè)業(yè)務(wù)線生成的訂單ID。

6.1 雪花算法優(yōu)化

雪花算法嚴(yán)重依賴系統(tǒng)時(shí)鐘。如果時(shí)鐘回?fù)?，就?huì)生成重復(fù)ID。

比如美團(tuán)的Leaf（美團(tuán)自研一種分布式ID生成系統(tǒng)），為了解決時(shí)鐘回?fù)埽肓藌ookeeper，原理也很簡(jiǎn)單，就是比較當(dāng)前系統(tǒng)時(shí)間跟生成節(jié)點(diǎn)的時(shí)間。

有的對(duì)并發(fā)要求更高的系統(tǒng)，比如雙十一秒殺，每毫秒4百萬(wàn)并發(fā)還不能滿足要求，就可以使用雪花算法和號(hào)段模式相結(jié)合，比如百度的UidGenerator、滴滴的TinyId。想想也是，號(hào)段模式的預(yù)先生成ID肯定是高性能分布式訂單ID的最終解決方案。

轉(zhuǎn)載自：面試官竟然問(wèn)我訂單ID是怎么生成的？難道不是MySQL自增主鍵？