← 返回目录

分库分表之后,id 主键如何处理?

第 29 / 72 卷日期:

8 台服务器,再到 16 台服务器。

  1. 由 DBA 负责将原先数据库服务器的库,迁移到新的数据库服务器上去,库迁移是有一些便

捷的工具的。

  1. 我们这边就是修改一下配置,调整迁移的库所在数据库服务器的地址。
  2. 重新发布系统,上线,原先的路由规则变都不用变,直接可以基于 n 倍的数据库服务器的

资源,继续进行线上系统的提供服务。

面试题

分库分表之后,id 主键如何处理?

面试官心理分析

其实这是分库分表之后你必然要面对的一个问题,就是 id 咋生成?因为要是分成多个表之后,每个表都是从 1 开始累加,那肯定不对啊,需要一个全局唯一的 id 来支持。所以这都是你实

际生产环境中必须考虑的问题。

面试题剖析

基于数据库的实现方案

数据库自增id

这个就是说你的系统里每次得到一个 id,都是往一个库的一个表里插入一条没什么业务含义的数据,然后获取一个数据库自增的一个 id。拿到这个 id 之后再往对应的分库分表里去写入。

这个方案的好处就是方便简单,谁都会用;缺点就是单库生成自增 id,要是高并发的话,就会有瓶颈的;如果你硬是要改进一下,那么就专门开一个服务出来,这个服务每次就拿到当前

id 最大值,然后自己递增几个 id,一次性返回一批 id,然后再把当前最大 id 值修改成递增几个 id 之后的一个值;但是无论如何都是基于单个数据库。

设置数据库sequence或者表自增字段步长

比如说,现在有 8 个服务节点,每个服务节点使用一个 sequence 功能来产生 ID,每个 sequence 的起始 ID 不同,并且依次递增,步长都是 8。

图 96-1
图 96-1

适合的场景:在用户防止产生的 ID 重复时,这种方案实现起来比较简单,也能达到性能目标。但是服务节点固定,步长也固定,将来如果还要增加服务节点,就不好搞了。

UUID

好处就是本地生成,不要基于数据库来了;不好之处就是,UUID 太长了、占用空间大,作为主键性能太差了;更重要的是,UUID 不具有有序性,会导致 B+ 树索引在写的时候有过多的随

机写操作(连续的 ID 可以产生部分顺序写),还有,由于在写的时候不能产生有顺序的 append 操作,而需要进行 insert 操作,将会读取整个 B+ 树节点到内存,在插入这条记录后会

将整个节点写回磁盘,这种操作在记录占用空间比较大的情况下,性能下降明显。

适合的场景:如果你是要随机生成个什么文件名、编号之类的,你可以用 UUID,但是作为主键

获取系统当前时间

这个就是获取当前时间即可,但是问题是,并发很高的时候,比如一秒并发几千,会有重复的情况,这个是肯定不合适的。基本就不用考虑了。

适合的场景:一般如果用这个方案,是将当前时间跟很多其他的业务字段拼接起来,作为一个 id,如果业务上你觉得可以接受,那么也是可以的。你可以将别的业务字段值跟当前时间拼接

起来,组成一个全局唯一的编号。

snowflake算法

snowflake 算法是 twitter 开源的分布式 id 生成算法,采用 Scala 语言实现,是把一个 64 位的 long 型的 id,1 个 bit 是不用的,用其中的 41 bits 作为毫秒数,用 10 bits 作为工作机器 id,12

bits 作为序列号。

1 bit:不用,为啥呢?因为二进制里第一个 bit 为如果是 1,那么都是负数,但是我们生成的 id 都是正数,所以第一个 bit 统一都是 0。

41 bits:表示的是时间戳,单位是毫秒。41 bits 可以表示的数字多达 2^41 - 1,也就是可以标识 2^41 - 1 个毫秒值,换算成年就是表示69年的时间。

10 bits:记录工作机器 id,代表的是这个服务最多可以部署在 2^10 台机器上,也就是 1024 台机器。但是 10 bits 里 5 个 bits 代表机房 id,5 个 bits 代表机器 id。意思就是最多代表

2^5 个机房(32 个机房),每个机房里可以代表 2^5 个机器(32台机器)。

12 bits:这个是用来记录同一个毫秒内产生的不同 id,12 bits 可以代表的最大正整数是 2^12 - 1 = 4096,也就是说可以用这个 12 bits 代表的数字来区分同一个毫秒内的

4096 个不同的 id。

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

java

public class IdWorker {

private long workerId;

private long datacenterId;

private long sequence;

if (datacenterId > maxDatacenterId || datacenterId < 0) {

throw new IllegalArgumentException(

String.format("datacenter Id can't be greater than %d

}

System.out.printf(

"worker starting. timestamp left shift %d, datacenter id b

timestampLeftShift, datacenterIdBits, workerIdBits, sequen

this.workerId = workerId;

this.datacenterId = datacenterId;

this.sequence = sequence;

}

private long twepoch = 1288834974657L;

private long workerIdBits = 5L;

private long datacenterIdBits = 5L;

// 这个是二进制运算,就是 5 bit最多只能有31个数字,也就是说机器id最多只能是32以内

private long maxWorkerId = -1L ^ (-1L << workerIdBits);

// 这个是一个意思,就是 5 bit最多只能有31个数字,机房id最多只能是32以内

private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

private long sequenceBits = 12L;

private long workerIdShift = sequenceBits;

private long datacenterIdShift = sequenceBits + workerIdBits;

private long timestampLeftShift = sequenceBits + workerIdBits + datace

private long sequenceMask = -1L ^ (-1L << sequenceBits);

private long lastTimestamp = -1L;

public long getWorkerId() {

return workerId;

}

public synchronized long nextId() {

// 这儿就是获取当前时间戳,单位是毫秒

long timestamp = timeGen();

if (timestamp < lastTimestamp) {

System.err.printf("clock is moving backwards.Rejecting reque

throw new RuntimeException(String.format(

"Clock moved backwards.Refusing to generate id for %

}

if (lastTimestamp == timestamp) {

// 这个意思是说一个毫秒内最多只能有4096个数字

// 无论你传递多少进来,这个位运算保证始终就是在4096这个范围内,避免你自己

sequence = (sequence + 1) & sequenceMask;

if (sequence == 0) {

timestamp = tilNextMillis(lastTimestamp);

}

} else {

sequence = 0;

}

// 这儿记录一下最近一次生成id的时间戳,单位是毫秒

lastTimestamp = timestamp;

// 这儿就是将时间戳左移,放到 41 bit那儿;

// 将机房 id左移放到 5 bit那儿;

// 将机器id左移放到5 bit那儿;将序号放最后12 bit;

// 最后拼接起来成一个 64 bit的二进制数字,转换成 10 进制就是个 long 型

return ((timestamp - twepoch) << timestampLeftShift) | (datacenter

| (workerId << workerIdShift) | sequence;

}

private long tilNextMillis(long lastTimestamp) {

long timestamp = timeGen();

while (timestamp <= lastTimestamp) {

timestamp = timeGen();

// ---------------测试---------------

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 以内),另外 5 bit 是你传递进来的机器

id(但是最大只能是 32 以内),剩下的那个 12 bit序列号,就是如果跟你上次生成 id 的时间还在一个毫秒内,那么会把顺序给你累加,最多在 4096 个序号以内。

所以你自己利用这个工具类,自己搞一个服务,然后对每个机房的每个机器都初始化这么一个东西,刚开始这个机房的这个机器的序号就是 0。然后每次接收到一个请求,说这个机房的这

个机器要生成一个 id,你就找到对应的 Worker 生成。

利用这个 snowflake 算法,你可以开发自己公司的服务,甚至对于机房 id 和机器 id,反正给你预留了 5 bit + 5 bit,你换成别的有业务含义的东西也可以的。

这个 snowflake 算法相对来说还是比较靠谱的,所以你要真是搞分布式 id 生成,如果是高并发啥的,那么用这个应该性能比较好,一般每秒几万并发的场景,也足够你用了。

面试题

你们有没有做 MySQL 读写分离?如何实现 MySQL 的读写分离?MySQL 主从复制原理的是啥?

如何解决 MySQL 主从同步的延时问题?

面试官心理分析

高并发这个阶段,肯定是需要做读写分离的,啥意思?因为实际上大部分的互联网公司,一些

全站分卷索引 · 72 卷
  1. 1互联网 Java 工程师进阶知识完全扫盲
  2. 2为什么使用消息队列?
  3. 3如何保证消息队列的高可用?
  4. 4如何保证消息不被重复消费?
  5. 5如何保证消息的可靠性传输?
  6. 6如何保证消息的顺序性?
  7. 7如何解决消息队列的延时以及过期失效问题?
  8. 8如何设计一个消息队列?
  9. 9搜索引擎
  10. 10ES 的分布式架构原理是什么?
  11. 11ES 写入数据的工作原理是什么?
  12. 12ES 在数十亿级别数量下如何提高查询效率?
  13. 13ES 生产集群的部署架构是什么?
  14. 14缓存
  15. 15Redis 和 Memcached 有什么区别?
  16. 16Redis 都有哪些数据类型以及适用场景?
  17. 17Redis 的过期策略都有哪些?
  18. 18如何保证 Redis 高并发、高可用?
  19. 19Redis 主从架构是怎样的?
  20. 20Redis 的持久化有哪几种方式?
  21. 21Redis 如何基于哨兵集群实现高可用?
  22. 22Redis 集群模式的工作原理能说一下么?
  23. 23Redis 的雪崩、穿透和击穿,如何应对?
  24. 24如何保证缓存与数据库双写一致性?
  25. 25如何解决 Redis 的并发竞争问题?
  26. 26生产环境中的 Redis 是怎么部署的?
  27. 27分库分表如何平滑过渡?
  28. 28设计一个动态扩容缩容的分库分表方案?
  29. 29分库分表之后,id 主键如何处理?
  30. 30读写分离
  31. 31高并发系统
  32. 32分布式系统
  33. 33系统拆分
  34. 34分布式服务框架
  35. 35Dubbo 支持哪些序列化协议?
  36. 36Dubbo 负载均衡策略和集群容错策略?
  37. 37Dubbo 的 SPI 思想是什么?
  38. 38如何基于 Dubbo 进行服务治理?
  39. 39分布式服务接口的幂等性如何设计?
  40. 40分布式服务接口请求的顺序性如何保证?
  41. 41如何自己设计一个类似 Dubbo 的 RPC 框架?
  42. 42CAP 定理的 P 是什么?
  43. 43分布式锁
  44. 44分布式锁如何设计?
  45. 45分布式事务
  46. 46分布式会话
  47. 47高可用架构
  48. 48电商网站详情页系统架构
  49. 49Hystrix 线程池技术实现资源隔离
  50. 50Hystrix 信号量机制实现资源隔离
  51. 51Hystrix 隔离策略细粒度控制
  52. 52深入 Hystrix 执行时内部原理
  53. 53基于 request cache 请求缓存技术优化批量商品数据查询接口
  54. 54基于本地缓存的 fallback 降级机制
  55. 55深入 Hystrix 断路器执行原理
  56. 56深入 Hystrix 线程池隔离与接口限流
  57. 57基于 timeout 机制为服务接口调用超时提供安全保护
  58. 58限流
  59. 59熔断
  60. 60微服务架构
  61. 61从单体式架构迁移到微服务架构
  62. 62微服务的事件驱动数据管理
  63. 63选择微服务部署策略
  64. 64Spring Cloud微服务架构
  65. 65你所知道的微服务技术栈都有哪些?
  66. 66谈谈服务发现组件 Eureka 的主要调用过程?
  67. 67海量数据处理
  68. 68如何找出某一天访问百度网站最多的 IP?
  69. 69如何在大量的数据中找出不重复的整数?
  70. 70如何在大量的数据中判断一个数是否存在?
  71. 71如何统计不同电话号码的个数?
  72. 72如何按照 query 的频度排序?