分库分表如何处理主键ID

淡淡的烟草味﹌ 2023-10-08 20:24 54阅读 0赞

当关系型数据库数据量过大时，通常会采用分库分表降低数据库查表压力。分库分表有多种，有分一个库多张分表额，有分多个库多张表的。一般分库分表使用ShardingSphere分表，建分片键等。但是分库分表之后，主键ID如何处理呢？相同业务表不同分表的主键ID是不可以相同的。所以要考虑一下主键ID如何赋值的问题。  
有以下几种我了解或者涉及到过的主键ID的处理方式：

## 一、自动生成主键ID ##

这种方式一般会将主键设置为bitint类型，自增的。但是会存在一个问题，多张分表保证主键不冲突，因为在业务上来说，多张分表的数据组成某个业务，因此主键是不允许冲突的。  
当采用自动生成主键ID的方案时，可以设置固定的几张分表，每个分表的起点不一样，每次新增的步长一样，这样就可以保证每张分表的主键不冲突。  
举例，如某张表分表有10张，可以设置每张表的起始主键ID从1到10，每张分表主键ID递增步长为10。

<table> 
 <thead> 
  <tr> 
   <th>表名</th> 
   <th>起始主键ID</th> 
   <th>步长</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>table_1</td> 
   <td>1</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_2</td> 
   <td>2</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_3</td> 
   <td>3</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_4</td> 
   <td>4</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_5</td> 
   <td>5</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_6</td> 
   <td>6</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_7</td> 
   <td>7</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_8</td> 
   <td>8</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_9</td> 
   <td>9</td> 
   <td>10</td> 
  </tr> 
  <tr> 
   <td>table_10</td> 
   <td>10</td> 
   <td>10</td> 
  </tr> 
 </tbody> 
</table>

根据上面分表主键递增规律，每张表的行数如下递增

<table> 
 <thead> 
  <tr> 
   <th>表名</th> 
   <th>第一条数据</th> 
   <th>第二条</th> 
   <th>第三条</th> 
   <th>第四条</th> 
   <th>第五条</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>table_1</td> 
   <td>1</td> 
   <td>11</td> 
   <td>21</td> 
   <td>31</td> 
   <td>41</td> 
  </tr> 
  <tr> 
   <td>table_2</td> 
   <td>2</td> 
   <td>12</td> 
   <td>22</td> 
   <td>32</td> 
   <td>42</td> 
  </tr> 
  <tr> 
   <td>table_3</td> 
   <td>3</td> 
   <td>13</td> 
   <td>23</td> 
   <td>33</td> 
   <td>43</td> 
  </tr> 
  <tr> 
   <td>table_4</td> 
   <td>4</td> 
   <td>14</td> 
   <td>24</td> 
   <td>34</td> 
   <td>44</td> 
  </tr> 
  <tr> 
   <td>table_5</td> 
   <td>5</td> 
   <td>15</td> 
   <td>25</td> 
   <td>35</td> 
   <td>45</td> 
  </tr> 
  <tr> 
   <td>table_6</td> 
   <td>6</td> 
   <td>16</td> 
   <td>26</td> 
   <td>36</td> 
   <td>46</td> 
  </tr> 
  <tr> 
   <td>table_7</td> 
   <td>7</td> 
   <td>17</td> 
   <td>27</td> 
   <td>37</td> 
   <td>47</td> 
  </tr> 
  <tr> 
   <td>table_8</td> 
   <td>8</td> 
   <td>18</td> 
   <td>28</td> 
   <td>38</td> 
   <td>48</td> 
  </tr> 
  <tr> 
   <td>table_9</td> 
   <td>9</td> 
   <td>19</td> 
   <td>29</td> 
   <td>39</td> 
   <td>49</td> 
  </tr> 
  <tr> 
   <td>table_10</td> 
   <td>10</td> 
   <td>20</td> 
   <td>30</td> 
   <td>40</td> 
   <td>50</td> 
  </tr> 
 </tbody> 
</table>

按照主键递增格式有弊端，即新增表时，不好处理主键逻辑。这种主键ID递增的方式适用于分表比较固定的情况。

## 2.UUID做主键 ##

uuid获取方式：

String id = UUID.randomUUID();
    
    结果：
    647be5bd-a477-4eff-8e58-99a573bb14ec

在前几年的时候，uuid作为主键的表遍地都是，因为它数据范围之广，用法方便受很多人青睐。但是uuid长度为36位，即使去掉中间的“-”，长度也有32位，因此比较占用存储空间。  
因为uuid是无序的，因此新增到数据库时，数据表如果采用btree索引，那么每次新增一条数据都需要重新排序，比较费时间，因此uuid作为分表主键也是不太推荐的。

## 3.雪花算法 ##

采用SnowFlake算法生成唯一id，包含时间戳，工作中心id，数据中心id，序列号组成，结构如下：  
![在这里插入图片描述][a2c3af3c7c714d7e8f71c87f7ae8f36b.png_pic_center]  
（1）一位占位符：默认为0。最高位代表正负，1代表负数，0代表正数，默认为正数。  
（2）41位时间戳：毫秒级的时间，可以存69年，(1L << 41) / (1000L \* 60 \* 60 \* 24 \* 365) = 69年  
（3）5位工作中心id：十进制范围在0-31；5位数据中心id：十进制范围在0-31。两个组合在一起最多可以容纳1024个节点。  
（4）序列号：占用12bit，最多可以累加到4095。自增值支持同一毫秒内同一个节点可以生成4096个ID,这个值在同一毫秒同一节点上从0开始不断累加。(最大可以支持单节点差不多四百万的并发量)

java一般使用hutool中的IdUtil类生成雪花算法id。以下是代码解析  
（1）IdUtil

public class IdUtil {
        
    
        public IdUtil() {
        
        }
    
        /** @deprecated 创建Snowflake对象，已废弃 */
        @Deprecated
        public static Snowflake createSnowflake(long workerId, long datacenterId) {
        
            return new Snowflake(workerId, datacenterId);
        }
    
        /**
         * 根据工作中心id和数据中心id获取数据
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static Snowflake getSnowflake(long workerId, long datacenterId) {
        
            return (Snowflake) Singleton.get(Snowflake.class, new Object[]{
        workerId, datacenterId});
        }
    
        /**
         * 根据工作中心id获取数据
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static Snowflake getSnowflake(long workerId) {
        
            return (Snowflake) Singleton.get(Snowflake.class, new Object[]{
        workerId});
        }
    
        /**
         * 无参获取Snowflake
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static Snowflake getSnowflake() {
        
            return (Snowflake) Singleton.get(Snowflake.class, new Object[0]);
        }
    
        /**
         * 根据数据中心id计算算法id中的数据中心值
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static long getDataCenterId(long maxDatacenterId) {
        
            Assert.isTrue(maxDatacenterId > 0L, "maxDatacenterId must be > 0", new Object[0]);
            //9223372036854775807L转成二进制，由63位的1组成
            if (maxDatacenterId == 9223372036854775807L) {
        
                --maxDatacenterId;
            }
    
            long id = 1L;
            byte[] mac = null;
    
            try {
        
                mac = NetUtil.getLocalHardwareAddress();
            } catch (UtilException var6) {
        
            }
    
            if (null != mac) {
        
                id = (255L & (long) mac[mac.length - 2] | 65280L & (long) mac[mac.length - 1] << 8) >> 6;
                //取余
                id %= maxDatacenterId + 1L;
            }
    
            return id;
        }
    
        /**
         * 获取算法id中的工作中心id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static long getWorkerId(long datacenterId, long maxWorkerId) {
        
            StringBuilder mpid = new StringBuilder();
            mpid.append(datacenterId);
    
            try {
        
                mpid.append(RuntimeUtil.getPid());
            } catch (UtilException var6) {
        
            }
    
            return (long) (mpid.toString().hashCode() & '\uffff') % (maxWorkerId + 1L);
        }
    
        /**
         * 无参获取算法id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static long getSnowflakeNextId() {
        
            return getSnowflake().nextId();
        }
    
        /**
         * 无参获取字符串类型算法id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public static String getSnowflakeNextIdStr() {
        
            return getSnowflake().nextIdStr();
        }
    }

(2) Snowflake类（核心类）

public class Snowflake implements Serializable {
        
        private static final long serialVersionUID = 1L;
        public static long DEFAULT_TWEPOCH = 1288834974657L; //时间戳，二进制为41位，对应时间为2010-11-04 09:42:54
        public static long DEFAULT_TIME_OFFSET = 2000L;  //允许时钟回拨差值，两秒
        private static final long WORKER_ID_BITS = 5L;  //工作中心位数
        private static final long MAX_WORKER_ID = 31L; //最大工作中心id值
        private static final long DATA_CENTER_ID_BITS = 5L; //数据中心位数
        private static final long MAX_DATA_CENTER_ID = 31L; //最大数据中心id值
        private static final long SEQUENCE_BITS = 12L;   //序列化位数
        private static final long WORKER_ID_SHIFT = 12L;  //工作中心移动位数（计算id用）
        private static final long DATA_CENTER_ID_SHIFT = 17L; //工作中心移动位数（（计算id用）计算id用）
        private static final long TIMESTAMP_LEFT_SHIFT = 22L; //时间戳移动位数
        private static final long SEQUENCE_MASK = 4095L;   //序列化最大值
        private final long twepoch;
        private final long workerId;
        private final long dataCenterId;
        private final boolean useSystemClock;
        private final long timeOffset;
        private final long randomSequenceLimit;
        private long sequence;
        private long lastTimestamp;
    
        /**
         * 无参构造
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake() {
        
            this(cn.hutool.core.util.IdUtil.getWorkerId(cn.hutool.core.util.IdUtil.getDataCenterId(31L), 31L));
        }
    
        /**
         * 根据工作中心id构造
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake(long workerId) {
        
            this(workerId, IdUtil.getDataCenterId(31L));
        }
    
        /**
         * 根据工作中心id和数据中心id构造
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake(long workerId, long dataCenterId) {
        
            this(workerId, dataCenterId, false);
        }
    
        /**
         * 参数：工作中心id、数据中心id、是否采用系统时间
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake(long workerId, long dataCenterId, boolean isUseSystemClock) {
        
            this((Date) null, workerId, dataCenterId, isUseSystemClock);
        }
    
        /**
         * 参数：时间，工作中心id、数据中心id、是否采用系统时间
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake(Date epochDate, long workerId, long dataCenterId, boolean isUseSystemClock) {
        
            this(epochDate, workerId, dataCenterId, isUseSystemClock, DEFAULT_TIME_OFFSET);
        }
    
        /**
         * 参数：工作中心id、数据中心id、是否采用系统时间， 允许时针回拨的时长
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake(Date epochDate, long workerId, long dataCenterId, boolean isUseSystemClock, long timeOffset) {
        
            this(epochDate, workerId, dataCenterId, isUseSystemClock, timeOffset, 0L);
        }
    
        /**
         * 参数：工作中心id、数据中心id、是否采用系统时间， 允许时针回拨的时长，序列化
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public Snowflake(Date epochDate, long workerId, long dataCenterId, boolean isUseSystemClock, long timeOffset, long randomSequenceLimit) {
        
            this.sequence = 0L;
            this.lastTimestamp = -1L;
            this.twepoch = null != epochDate ? epochDate.getTime() : DEFAULT_TWEPOCH;
            this.workerId = Assert.checkBetween(workerId, 0L, 31L);
            this.dataCenterId = Assert.checkBetween(dataCenterId, 0L, 31L);
            this.useSystemClock = isUseSystemClock;
            this.timeOffset = timeOffset;
            this.randomSequenceLimit = Assert.checkBetween(randomSequenceLimit, 0L, 4095L);
        }
    
        /**
         * 获取工作中心id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public long getWorkerId(long id) {
        
            return id >> 12 & 31L;
        }
    
        /**
         * 获取数据中心id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public long getDataCenterId(long id) {
        
            return id >> 17 & 31L;
        }
    
        /**
         * 获取时间戳
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public long getGenerateDateTime(long id) {
        
            return (id >> 22 & 2199023255551L) + this.twepoch;
        }
    
        /**
         * 获取id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public synchronized long nextId() {
        
            //获取当前时间戳，默认取项目时间
            long timestamp = this.genTime();
            if (timestamp < this.lastTimestamp) {
        
                //校验时间回拨差值是否大于配置的差值，若是，则报错
                if (this.lastTimestamp - timestamp >= this.timeOffset) {
        
                    throw new IllegalStateException(StrUtil.format("Clock moved backwards. Refusing to generate id for {}ms", new Object[]{
        this.lastTimestamp - timestamp}));
                }
                //将上次时间戳赋值给当前时间
                timestamp = this.lastTimestamp;
            }
    
            //设置序列化号
            if (timestamp == this.lastTimestamp) {
        
                //设置序列化号，上次序列化号+1之后与4095进行与计算。
                long sequence = this.sequence + 1L & 4095L;
                if (sequence == 0L) {
        
                    // 毫秒内序列溢出（序列化号已满，说明当前秒的序列化号都已被占用过） 阻塞到下一个毫秒，获得新的时间戳
                    timestamp = this.tilNextMillis(this.lastTimestamp);
                }
                //记录当前的序列化号
                this.sequence = sequence;
            } else if (this.randomSequenceLimit > 1L) {
        
                //当timestamp > this.lastTimestamp且this.randomSequenceLimit > 1L，则随便设置一个不大于等于randomSequenceLimit的值赋予sequence
                this.sequence = RandomUtil.randomLong(this.randomSequenceLimit);
            } else {
        
                //当timestamp > this.lastTimestamp且this.randomSequenceLimit <= 1时，则默认设置sequence=0
                this.sequence = 0L;
            }
    
            //将计算完的时间戳赋予全局变量
            this.lastTimestamp = timestamp;
            //将时间戳（当前时间戳-默认的时间，这样可以时间戳值的范围更大些），数据中心，工作中心，序列化拼接在一起组成id。
            return timestamp - this.twepoch << 22 | this.dataCenterId << 17 | this.workerId << 12 | this.sequence;
        }
    
        /**
         * 获取字符串算法id
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        public String nextIdStr() {
        
            return Long.toString(this.nextId());
        }
    
        /**
         * 计算下一个时间
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        private long tilNextMillis(long lastTimestamp) {
        
            long timestamp;
            //计算时间，目的是算出当前时间，最大只能等于传进来的参数时间
            for (timestamp = this.genTime(); timestamp == lastTimestamp; timestamp = this.genTime()) {
        
            }
    
            if (timestamp < lastTimestamp) {
        
                throw new IllegalStateException(StrUtil.format("Clock moved backwards. Refusing to generate id for {}ms", new Object[]{
        lastTimestamp - timestamp}));
            } else {
        
                return timestamp;
            }
        }
    
        /**
         * 生成时间戳
         *
         * @author zhouxy
         * @date 2023/5/12
         */
        private long genTime() {
        
            //SystemClock.now() 获取当前项目计算的时间
            //System.currentTimeMillis()获取的是当前系统时间
            return this.useSystemClock ? SystemClock.now() : System.currentTimeMillis();
        }
    }

上面是hutool中提供的雪花算法，与原始的雪花算法区别在于，hutool中允许一定范围的时间回拨。  
hutool中的雪花算法的优缺点：  
优点  
（1）按照时间排序，则数据库存储时不需要重复排序变动存储位置。  
（2）可使用范围长，时间戳的位数41位，可支持69年。  
缺点  
（1）允许时针回拨，在某些极端情况下会产生重复id

结语：除了上面的几种id生成算法，当然还有其他的主键id生成算法，具体使用哪种需要根据业务的情况来使用。

[a2c3af3c7c714d7e8f71c87f7ae8f36b.png_pic_center]: https://img-blog.csdnimg.cn/a2c3af3c7c714d7e8f71c87f7ae8f36b.png#pic_center