分佈式系統惟一性ID生成策略思考

時間 2019-11-06

標籤分佈式系統惟一生成策略思考欄目系統架構简体版

原文原文鏈接

多種ID生成方式

1. UUID

算法的核心思想是結合機器的網卡、當地時間、一個隨記數來生成UUID。java

優勢：本地生成，性能好，沒有高可用風險；
缺點：長度過長，且無序

2. 數據庫sequence

使用數據庫的id自增策略，如MySQL的auto_increment。而且可使用兩臺數據庫分別設置不一樣步長，生成不重複ID的策略來實現高可用。git

優勢：數據庫生成的ID絕對有序，高可用實現方式簡單。
缺點：須要獨立部署數據庫實例，成本高，有性能瓶頸

3.雪花算法

twitter生成全局ID生成器的算法策略。github

簡單來講：就是把64的Long型數據由如下幾個部分組成：
符號位(1位)-時間戳(41位)-數據中心標識(5位)-ID生成器實例標識(5位)-序列號(12位)
經過部署多個ID生成器，位各個業務系統生成全局惟一的Long型ID。redis

優勢：生成Long型易操做，有序
缺點：須要獨立部署id生成器，增長維護成本

4.MongoDB ObjectId

生成策略相似雪花算法。算法

時間戳+機器ID+進程ID+序列號=>ObjectId對象數據庫

優勢：本地生成，有序，成本低
缺點：使用機器ID和進程ID，64位Long沒法存儲，只能生成特殊ObjectId對象。

總結對比

方式	優勢	缺點
UUID	本地生成，無中心，無性能瓶頸	無序，過長
MongoDB ObjectId	本地生成，含時間戳，有序	過長
數據庫sequence	有序	中心生成，獨立部署數據庫
雪花算法	有序，Long型	中心生成，獨立部署ID生成器

大體的總結優略點以下：緩存

方式	優勢	缺點
UUID	本地生成，無中心，無性能瓶頸	無序，過長
MongoDB ObjectId	本地生成，含時間戳，有序	過長
數據庫sequence	有序	中心生成，獨立部署數據庫
雪花算法	有序，Long型	中心生成，獨立部署ID生成器

想要的

看了以上，我想要的ID生成策略是怎樣的呢？
64位易操做存儲，按時間有序，無中心本地生成。
好吧，其實本文也沒有徹底實現以上需求，若是哪位小夥伴有更好方案歡迎回復分享！！！
本文只是基於對以上幾種方案的認識，稍加改進，儘量的知足需求！架構

來吧

個人想法：app

使用Long型，不可避免參考雪花算法的實現，可是要實現本地化生成，要參考ObjectId的生成策略，使用相似機器ID，進程ID來保證惟一性。分佈式

如何解決使用機器ID，進程ID時致使ID過長的問題？

解決方式：放棄使用機器ID，進程ID，使用serverId標識服務，使用instanceId標識服務進程，可是。。。沒辦法，須要一箇中心來進行註冊，保證惟一性，本例中使用Redis（不限於redis，database，memcached均可）。

相對於使用獨立部署的ID生成器，我想Redis之類的緩存集羣是各個分佈式系統架構中都會存在的，這樣能夠顯著下降架構複雜度，下降成本。
對redis的依賴較低，能夠說只須要啓動的時候訪問redis便可，後續本地生成ID。
另外serverId是固定不變的，是能夠預先分配好的，好比會員中心微服務的serverId分配爲10，這是固定不變的。

大體實現

相似雪花算法的參數

public class IdGenerator {

    // 時間基線  2016/1/1
    private final long timeBaseLine = 1454315864414L;

    // 服務編號
    private volatile long serverId = -1;

    //服務實例編號
    private volatile long instanceId = -1;
    
    private static final long serverIdBits = 7;
    private static final long instanceIdBits = 10;
    private static final long sequenceBits = 5;
    ...
}

serverIdBits = 7，最多支持128個服務。
instanceIdBits = 10，每一個服務支持1024個實例。
sequenceBits = 5，每毫秒可生成的id數量32個（因爲本地生成，且時間戳精確到毫秒，同一毫秒內的ID衝突不會像中心那麼嚴重。）

簡單流程

服務A請求redis分配instanceId

主要方法：

/**
     * 應用啓動完成後調用init
     *
     * @param serverId
     */
    public synchronized void init(long serverId) {
        this.serverId = serverId;
        if (!inited) {
            inited = true;
            Jedis jedis = new Jedis("localhost", 6379);
            ScheduledExecutorService scheduledService = Executors.newScheduledThreadPool(1);
            RegisterIdCreatorInstanceTask registerIdCreatorInstanceTask = new RegisterIdCreatorInstanceTask(jedis);
            // 定義定時任務，按期調用redis註冊，續約instanceId
            scheduledService.scheduleWithFixedDelay(registerIdCreatorInstanceTask, 0, RegisterIdCreatorInstanceTask.INTERVAL_SECONDS, TimeUnit.SECONDS);
        } else {
            System.out.println("已經初始化！");
        }
    }
    
    /**
     * 註冊id生成器實例
     */
    private class RegisterIdCreatorInstanceTask implements Runnable {
        private Logger logger = Logger.getLogger(RegisterIdCreatorInstanceTask.class.getCanonicalName());

        public static final int INTERVAL_SECONDS = 30;

        private Jedis jedis;

        private RegisterIdCreatorInstanceTask(Jedis jedis) {
            this.jedis = jedis;
        }

        public void run() {

            try {

                long srvId = idGenerator.getServerId();
                long currentInstanceId = idGenerator.getInstanceId();

                String prefixKey = ID_CREATOR_KEY + KEY_SEP + srvId + KEY_SEP;

                if (currentInstanceId < 0) {
                    //註冊
                    registerInstanceIdWithIpv4();
                } else {
                    //續約
                    String result = jedis.set(prefixKey + currentInstanceId, srvId + KEY_SEP + currentInstanceId, "XX", "EX", INTERVAL_SECONDS * 3);
                    if (!"OK".equals(result)) {
                        logger.warning("服務[" + srvId + "]ID生成器：" + currentInstanceId + "續約失敗，等待從新註冊");
                        registerInstanceIdWithIpv4();
                    } else {
                        logger.info("服務[" + srvId + "]ID生成器：" + currentInstanceId + "續約成功");
                    }

                }

            } catch (JedisException e) {
                logger.severe("Redis 出現異常！");
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (idGenerator.getInstanceId() < 0) {
                    idGenerator.setInited(false);
                }
                if (jedis != null) {
                    jedis.close();
                }
            }
        }

        private int registerInstanceIdWithIpv4() {
            long ip4Value = getIp4LongValue();
            // Redis key 格式:key->val , ID_CREATOR:serverId:instanceId -> serverId:instanceId
            String prefixKey = ID_CREATOR_KEY + KEY_SEP + serverId + KEY_SEP;

            // 須要使用java8
            int regInstanceId = registerInstanceId((int) (ip4Value % (maxInstanceId + 1)), (int) maxInstanceId, (v) -> {
                String res = jedis.set(prefixKey + v, serverId + KEY_SEP + v, "NX", "EX", INTERVAL_SECONDS * 3);
                return "OK".equals(res) ? v : -1;
            });

            idGenerator.setInstanceId(regInstanceId);
            idGenerator.setInited(true);

            logger.info("服務[" + serverId + "]註冊了一個ID生成器：" + regInstanceId);
            return regInstanceId;
        }


        /**
         * 註冊instance,成功就返回
         *
         * @param basePoint
         * @param max
         * @param action
         * @return
         */
        public int registerInstanceId(int basePoint, int max, Function<Integer, Integer> action) {
            int result;
            for (int i = basePoint; i <= max; i++) {
                result = action.apply(i);
                if (result > -1) {
                    return result;
                }
            }

            for (int i = 0; i < basePoint; i++) {
                result = action.apply(i);
                if (result > -1) {
                    return result;
                }
            }
            return 0;
        }

        /**
         * IPV4地址轉Long
         *
         * @return
         */
        private long getIp4LongValue() {
            try {
                InetAddress inetAddress = Inet4Address.getLocalHost();
                byte[] ip = inetAddress.getAddress();

                return Math.abs(((0L | ip[0]) << 24)
                        | ((0L | ip[1]) << 16)
                        | ((0L | ip[2]) << 8)
                        | (0L | ip[3]));

            } catch (Exception ex) {
                ex.printStackTrace();
                return 0;
            }
        }
    }
    
/**
     * 獲取ID
     *
     * @return
     */
    public long getId() {
        long id = nextId();
        return id;
    }

    private synchronized long nextId() {
        if (serverId < 0 || instanceId < 0) {
            throw new IllegalArgumentException("目前不能生成惟一性ID,serverId:[" + serverId + "],instanceId:[" + instanceId + "]!");
        }

        long timestamp = currentTime();
        if (timestamp < lastTimestamp) {
            throw new IllegalStateException("Err clock");
        }
        sequence = (sequence + 1) & maxSequence;
        if (lastTimestamp == timestamp) {
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        lastTimestamp = timestamp;

        long id = ((timestamp - timeBaseLine) << timeBitsShift)
                | (serverId << serverIdBitsShift)
                | (instanceId << instanceIdBitsShift)
                | sequence;
        return id;
    }

若有問題歡迎指正！！

若有其餘方案，歡迎回復告知，謝謝！！！

源碼 https://github.com/darren-fu/IdGenerator