P8大佬的 62条SQL优化策略，太牛X了！！收藏起来有大用！！！

旧城等待， 2024-03-26 17:52 46阅读 0赞

#### 背景说明： ####

Mysql调优，是大家日常常见的调优工作。所以**Mysql调优**是一个**非常、非常核心的面试知识点**。

在40岁老架构师 尼恩的**读者交流群**(50+)中，其相关面试题是一个非常、非常高频的交流话题。

只要一面试，基本就会问：

> 对mysql调优了解吗？
> 
> 你是怎么做调优的。

很多小伙伴，回答起来，就是干巴巴的几点。 导致给面试官的用户体验，非常差。

这里尼恩给大家 调优，做一下系统化、体系化的梳理。

结合咱们社群中几个P8大佬的优化策略、设计规范，统一为两大部分：

*  P8大佬的62条 SQL语句性能优化策略
 *  P8大佬的MySQL数据库设计规范

收藏起来有大用，大家平时在SQL优化的时候，可以复习一下，减少**生产事故**的发生。

在面试之前，也可以复习一下，使得大家可以充分展示一下大家雄厚的 “技术肌肉”，**让面试官爱到 “不能自已、口水直流”**。

也一并把这些宝贵内容作为“mysql调优的”参考答案，收入咱们的《[尼恩Java面试宝典][Java]》，供后面的小伙伴参考，提升大家的 3高 架构、设计、开发水平。

> 注：本文以 PDF 持续更新，最新尼恩 架构笔记、面试题 的PDF文件，请从这里获取：[码云][Link 1]

### 回顾：MySQL的执行过程 ###

回顾 MySQL的执行过程，帮助 介绍 如何进行sql优化。

（1）客户端发送一条查询语句到服务器；

（2）服务器先查询缓存，如果命中缓存，则立即返回存储在缓存中的数据；

（3）未命中缓存后，MySQL通过关键字将SQL语句进行解析，并生成一颗对应的解析树，MySQL解析器将使用MySQL语法进行验证和解析。

例如，验证是否使用了错误的关键字，或者关键字的使用是否正确；

（4）预处理是根据一些MySQL规则检查解析树是否合理，比如检查表和列是否存在，还会解析名字和别名，然后预处理器会验证权限；

根据执行计划查询执行引擎，调用API接口调用存储引擎来查询数据；

（5）将结果返回客户端，并进行缓存；

![20200330211824877.png][]

### P8大佬的62条 SQL语句性能优化策略 ###

#### 1、 为 WHERE 及 ORDER BY 涉及的列上建立索引 ####

对查询进行优化，应尽量避免全表扫描，首先应考虑在 WHERE 及 ORDER BY 涉及的列上建立索引。

#### 2、where中使用默认值代替null ####

应尽量避免在 WHERE 子句中对字段进行 NULL 值判断，创建表时 NULL 是默认值，但大多数时候应该使用 NOT NULL，或者使用一个特殊的值，如 0，-1 作为默认值。

为啥建议where中使用默认值代替null，四个原因：

（1）并不是说使用了is null或者 is not null就会不走索引了，这个跟mysql版本以及查询成本都有关；

（2）如果mysql优化器发现，走索引比不走索引成本还要高，就会放弃索引，这些条件 !=，<>，is null，is not null经常被认为让索引失效；

（3）其实是因为一般情况下，查询的成本高，优化器自动放弃索引的；

（4）如果把null值，换成默认值，很多时候让走索引成为可能，同时，表达意思也相对清晰一点；

#### 3、慎用 != 或 <> 操作符。 ####

MySQL 只有对以下操作符才使用索引：<，<=，=，>，>=，BETWEEN，IN，以及某些时候的 LIKE。

所以：应尽量避免在 WHERE 子句中使用 != 或 <> 操作符， 会导致全表扫描。

#### 4、慎用 OR 来连接条件 ####

使用or可能会使索引失效，从而全表扫描；

应尽量避免在 WHERE 子句中使用 OR 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，

可以使用 UNION 合并查询：

select id from t where num=10 
    
    union all 
    
    select id from t where num=20

一个关键的问题是否用到索引。

他们的速度只同是否使用索引有关，如果查询需要用到联合索引，用 UNION all 执行的效率更高。

多个 OR 的字句没有用到索引，改写成 UNION 的形式再试图与索引匹配。

#### 5、慎用 IN 和 NOT IN ####

IN 和 NOT IN 也要慎用，否则会导致全表扫描。对于连续的数值，能用 BETWEEN 就不要用 IN：select id from t where num between 1 and 3。

#### 6、慎用 左模糊like ‘%…’ ####

模糊查询，程序员最喜欢的就是使用like，like很可能让索引失效。

比如：

select id from t where name like‘%abc%’ 
    select id from t where name like‘%abc’

而select id from t where name like‘abc%’才用到索引。

所以：

*  首先尽量避免模糊查询，如果必须使用，不采用全模糊查询，也应尽量采用右模糊查询， 即like ‘…%’，是会使用索引的；
 *  左模糊like ‘%…’无法直接使用索引，但可以利用reverse + function index的形式，变化成 like ‘…%’；
 *  全模糊查询是无法优化的，一定要使用的话建议使用搜索引擎，比如 ElasticSearch。

*尼恩备注：如果一定要用左模糊like ‘%…’检索， 一般建议 ElasticSearch+Hbase架构，*

*具体请参考尼恩的3高架构笔记。*

#### 7、WHERE条件使用参数会导致全表扫描。 ####

如下面语句将进行全表扫描：

select id from t where num=@num

因为SQL只有在**运行时**才会解析局部变量，但优化程序不能将访问计划的选择推 迟到 **运行时**；

它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。

所以， 可以改为强制查询使用索引：

select id from t with(index(索引名)) where num=@num

#### 8、应避免WHERE 表达式操作/对字段进行函数操作 ####

任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，

应尽量避免在 WHERE 子句中对字段进行表达式操作，应尽量避免在 WHERE 子句中对字段进行函数操作。

如：

select id from t where num/2=100
    应改为:
    select id from t where num=100*2

应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。  
如：

select id from t where substring(name,1,3)=‘abc’
    
    select id from t where datediff(day,createdate,‘2005-11-30’)=0
    
    应改为:
    
    select id from t where name like ‘abc%’
    
    select id from t where createdate>=‘2005-11-30’ and createdate<‘2005-12-1’

#### 9、用 EXISTS 代替 IN 是一个好的选择 ####

很多时候用exists 代替in 是一个好的选择：

select num from a where num in(select num from b)
    用下面的语句替换：
    select num from a where exists(select 1 from b where num=a.num)

#### 10、索引并不是越多越好 ####

索引固然可以提高相应的 SELECT 的效率，但同时也降低了 INSERT 及 UPDATE 的效。

因为 INSERT 或 UPDATE 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。

一个表的索引数最好不要超过 6 个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。

#### 11、应尽可能的避免更新 clustered 索引数据列 ####

应尽可能的避免更新 clustered 索引数据列， 因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，

一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。

若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

#### 12、尽量使用数字型字段 ####

（1）因为引擎在处理查询和连接时会逐个比较字符串中每一个字符；

（2）而对于数字型而言只需要比较一次就够了；

（3）字符会降低查询和连接的性能，并会增加存储开销；

所以：

尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。

#### 13、尽可能的使用 varchar, nvarchar 代替 char, nchar ####

（1）varchar变长字段按数据内容实际长度存储，存储空间小，可以节省存储空间；

（2）char按声明大小存储，不足补空格；

（3）其次对于查询来说，在一个相对较小的字段内搜索，效率更高；

因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。

#### 14、查询SQL尽量不要使用select \*，而是具体字段 ####

最好不要使用返回所有：select \* from t ，用具体的字段列表代替 “\*”，不要返回用不到的任何字段。

**select \*的弊端：**

（1）增加很多不必要的消耗，比如CPU、IO、内存、网络带宽；

（2）增加了使用覆盖索引的可能性；

（3）增加了回表的可能性；

（4）当表结构发生变化时，前端也需要更改；

（5）查询效率低；

#### 15、尽量避免向客户端返回大数据量 ####

大数据量增加很多不必要的消耗，比如CPU、IO、内存、网络带宽

尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

#### 16、使用表的别名（Alias）： ####

当在 SQL 语句中连接多个表时，请使用表的别名并把别名前缀于每个 Column 上。

这样一来，就可以减少解析的时间并减少那些由 Column 歧义引起的语法错误。

#### 17、使用“临时表”暂存中间结果 ： ####

简化 SQL 语句的重要方法就是采用临时表暂存中间结果。

但是临时表的好处远远不止这些，将临时结果暂存在临时表，后面的查询就在 tempdb 中了，这可以避免程序中多次扫描主表，也大大减少了程序执行中“共享锁”阻塞“更新锁”，减少了阻塞，提高了并发性能。

#### 18、一些 SQL 查询语句应加上 nolock。 ####

一些 SQL 查询语句应加上 nolock，读、写是会相互阻塞的，为了提高并发性能。

对于一些查询，可以加上 nolock，这样读的时候可以允许写，但缺点是可能读到未提交的脏数据。

使用 nolock 有3条原则：

*  查询的结果用于“插、删、改”的不能加 nolock；
 *  查询的表属于频繁发生页分裂的，慎用 nolock ；
 *  使用临时表一样可以保存“数据前影”，起到类似 Oracle 的 undo 表空间的功能，能采用临时表提高并发性能的，不要用 nolock。

#### 19、常见的简化规则如下： ####

不要有超过 5 个以上的表连接（JOIN），考虑使用临时表或表变量存放中间结果。

少用子查询，视图嵌套不要过深，一般视图嵌套不要超过 2 个为宜。

#### 20、将需要查询的结果预先计算好 ####

将需要查询的结果预先计算好放在表中，查询的时候再Select，而不是查询的时候进行计算。

这在SQL7.0以前是最重要的手段，例如医院的住院费计算。

#### 21、IN后出现最频繁的值放在最前面 ####

如果一定用IN，那么：

在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面，减少判断的次数。

#### 22、使用存储过程进行数据处理 ####

尽量将数据的处理工作放在服务器上，减少网络的开销，如使用存储过程。

存储过程是编译好、优化过、并且被组织到一个执行规划里、且存储在数据库中的 SQL 语句，是控制流语言的集合，速度当然快。反复执行的动态 SQL，可以使用临时存储过程，该过程（临时表）被放在 Tempdb 中。

#### 23、尽量使用 EXISTS 代替 select count(1) 来判断是否存在记录。 ####

count 函数只有在统计表中所有行数时使用，而且 count(1) 比 count(\*) 更有效率。

#### 24、索引的使用规范： ####

*  索引的创建要与应用结合考虑，建议大的 OLTP 表不要超过 6 个索引；
 *  尽可能的使用索引字段作为查询条件，尤其是聚簇索引，必要时可以通过 index index\_name 来强制指定索引；
 *  避免对大表查询时进行 table scan，必要时考虑新建索引；
 *  在使用索引字段作为条件时，如果该索引是联合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用；
 *  要注意索引的维护，周期性重建索引，重新编译存储过程。

#### 25、下列 SQL 条件语句中的列都建有恰当的索引，但执行速度却非常慢： ####

SELECT * FROM record WHERE substrINg(card_no, 1, 4) = '5378' --13秒 
    
    SELECT * FROM record WHERE amount/30 < 1000 --11秒 
    
    SELECT * FROM record WHERE convert(char(10), date, 112) = '19991201' --10秒

分析：

WHERE 子句中对列的任何操作结果都是在 SQL 运行时逐列计算得到的，因此它不得不进行表搜索，而没有使用该列上面的索引。

如果这些结果在查询编译时就能得到，那么就可以被 SQL 优化器优化，使用索引，避免表搜索，因此将 SQL 重写成下面这样：

SELECT * FROM record WHERE card_no like '5378%' -- < 1秒 
    
    SELECT * FROM record WHERE amount < 1000*30 -- < 1秒 
    
    SELECT * FROM record WHERE date = '1999/12/01' -- < 1秒

#### 26、用批量插入或批量更新 ####

当有一批处理的插入或更新时，用批量插入或批量更新，绝不会一条条记录的去更新。

（1）多条提交

INSERT INTO user (id,username) VALUES(1,'技术自由圈');
    INSERT INTO user (id,username) VALUES(2,'疯狂创客圈');

（2）批量提交

INSERT INTO user (id,username) VALUES(1,'技术自由圈'),(2,'疯狂创客圈');

默认新增SQL有事务控制，导致每条都需要事务开启和事务提交，而批量处理是一次事务开启和提交，效率提升明显，达到一定量级，效果显著，平时看不出来。

#### 27、存储过程中慎用循环 ####

在所有的存储过程中，能够用 SQL 语句的，我绝不会用循环去实现。

例如：列出上个月的每一天，我会用 connect by 去递归查询一下，绝不会去用循环从上个月第一天到最后一天。

#### 28、选择最有效率的表名顺序 ####

选择最有效率的表名顺序（只在基于规则的优化器中有效）： Oracle 的解析器按照从右到左的顺序处理 FROM 子句中的表名，FROM 子句中写在最后的表（基础表 driving table）将被最先处理，在 FROM 子句中包含多个表的情况下，你必须选择记录条数最少的表作为基础表。

如果有 3 个以上的表连接查询，那就需要选择交叉表（interp table）作为基础表，交叉表是指那个被其他表所引用的表。

##### 29、将不需要的记录在 GROUP BY 之前过滤掉 #####

提高 GROUP BY 语句的效率，可以通过将不需要的记录在 GROUP BY 之前过滤掉。

下面两个查询返回相同结果，但第二个明显就快了许多。

低效：

SELECT JOB, AVG(SAL) 
    FROM EMP 
    GROUP BY JOB 
    HAVING JOB = 'PRESIDENT' 
    OR JOB = 'MANAGER'

高效：

SELECT JOB, AVG(SAL) 
    FROM EMP
    WHERE JOB = 'PRESIDENT' 
    OR JOB = 'MANAGER' 
    GROUP BY JOB

#### 30、别名的使用， ####

别名是大型数据库的应用技巧，就是表名、列名在查询中以一个字母为别名，查询速度要比建连接表快 1.5 倍。

#### 31、避免死锁， ####

在你的存储过程和触发器中访问同一个表时总是以相同的顺序；事务应经可能地缩短，在一个事务中应尽可能减少涉及到的数据量；永远不要在事务中等待用户输入。

#### 32、避免使用临时表，可以使用表变量代替 ####

避免使用临时表，除非却有需要，否则应尽量避免使用临时表，相反，可以使用表变量代替。

大多数时候（99%），表变量驻扎在内存中，因此速度比临时表更快，

临时表驻扎在 TempDb 数据库中，因此临时表上的操作需要跨数据库通信，速度自然慢。

#### 33、最好不要使用触发器： ####

*  触发一个触发器，执行一个触发器事件本身就是一个耗费资源的过程；
 *  如果能够使用约束实现的，尽量不要使用触发器；
 *  不要为不同的触发事件（Insert、Update 和 Delete）使用相同的触发器；
 *  不要在触发器中使用事务型代码。

#### 34、索引创建规则： ####

*  表的主键、外键必须有索引；
 *  数据量超过 300 的表应该有索引；
 *  经常与其他表进行连接的表，在连接字段上应该建立索引；
 *  经常出现在 WHERE 子句中的字段，特别是大表的字段，应该建立索引；
 *  索引应该建在选择性高的字段上；
 *  索引应该建在小字段上，对于大的文本字段甚至超长字段，不要建索引；
 *  复合索引的建立需要进行仔细分析，尽量考虑用单字段索引代替；
 *  正确选择复合索引中的主列字段，一般是选择性较好的字段；
 *  复合索引的几个字段是否经常同时以 AND 方式出现在 WHERE 子句中？单字段查询是否极少甚至没有？如果是，则可以建立复合索引；否则考虑单字段索引；
 *  如果复合索引中包含的字段经常单独出现在 WHERE 子句中，则分解为多个单字段索引；
 *  如果复合索引所包含的字段超过 3 个，那么仔细考虑其必要性，考虑减少复合的字段；
 *  如果既有单字段索引，又有这几个字段上的复合索引，一般可以删除复合索引；
 *  频繁进行数据操作的表，不要建立太多的索引；
 *  删除无用的索引，避免对执行计划造成负面影响；
 *  表上建立的每个索引都会增加存储开销，索引对于插入、删除、更新操作也会增加处理上的开销。另外，过多的复合索引，在有单字段索引的情况下，一般都是没有存在价值的；相反，还会降低数据增加删除时的性能，特别是对频繁更新的表来说，负面影响更大。
 *  尽量不要对数据库中某个含有大量重复的值的字段建立索引。

#### 35、在写 SQL 语句时，应尽量减少空格的使用 ####

查询缓冲并不自动处理空格，

因此，在写 SQL 语句时，应尽量减少空格的使用，尤其是在 SQL 首和尾的空格（因为查询缓冲并不自动截取首尾空格）。

#### 36、member 用 mid 做标准进行分表方便查询么？ ####

member 用 mid 做标准进行分表方便查询么？

一般的业务需求中基本上都是以 username 为查询依据，正常应当是 username 做 hash 取模来分表。

而分表的话 MySQL 的 partition 功能就是干这个的，对代码是透明的；在代码层面去实现貌似是不合理的。

#### 37、每张表都设置一个 ID 做为其主键 ####

我们应该为数据库里的每张表都设置一个 ID 做为其主键，而且最好的是一个 INT 型的（推荐使用 UNSIGNED），并设置上自动增加的 AUTO\_INCREMENT 标志。

#### 38、在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ####

在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON，在结束时设置 SET NOCOUNT OFF。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE\_IN\_PROC 消息。

#### 39、MySQL 查询可以启用高速查询缓存。 ####

这是提高数据库性能的有效MySQL优化方法之一。当同一个查询被执行多次时，从缓存中提取数据和直接从数据库中返回数据快很多。

#### 40、EXPLAIN SELECT 查询用来跟踪查看效果： ####

使用 EXPLAIN 关键字可以让你知道 MySQL 是如何处理你的 SQL 语句的。

这可以帮你分析你的查询语句或是表结构的性能瓶颈。

EXPLAIN 的查询结果还会告诉你你的索引主键被如何利用的，你的数据表是如何被搜索和排序的。

#### 41、当只要一行数据时使用 LIMIT 1 ： ####

当你查询表的有些时候，你已经知道结果只会有一条结果，但因为你可能需要去fetch游标，或是你也许会去检查返回的记录数。

在这种情况下，加上 LIMIT 1 可以增加性能。

这样一来，MySQL 数据库引擎会在找到一条数据后停止搜索，而不是继续往后查少下一条符合记录的数据。

#### 42、选择表合适存储引擎： ####

*  **myisam**：应用时以读和插入操作为主，只有少量的更新和删除，并且对事务的完整性，并发性要求不是很高的。
 *  **InnoDB**：事务处理，以及并发条件下要求数据的一致性。除了插入和查询外，包括很多的更新和删除。（InnoDB 有效地降低删除和更新导致的锁定）。

对于支持事务的 InnoDB类 型的表来说，影响速度的主要原因是 AUTOCOMMIT 默认设置是打开的，而且程序没有显式调用 BEGIN 开始事务，导致每插入一条都自动提交，严重影响了速度。可以在执行 SQL 前调用 begin，多条 SQL 形成一个事物（即使 autocommit 打开也可以），将大大提高性能。

#### 43、优化表的数据类型，选择合适的数据类型： ####

\*\*原则：\*\*更小通常更好，简单就好，所有字段都得有默认值，尽量避免 NULL。

例如：数据库表设计时候更小的占磁盘空间尽可能使用更小的整数类型。(mediumint 就比 int 更合适)

比如时间字段：datetime 和 timestamp。datetime 占用8个字节，timestamp 占用4个字节，只用了一半。而 timestamp 表示的范围是 1970—2037 适合做更新时间。

MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。

因此，在创建表的时候，为了获得更好的性能，我们可以将表中字段的宽度设得尽可能小。

例如：在定义邮政编码这个字段时，如果将其设置为 CHAR(255)，显然给数据库增加了不必要的空间。甚至使用VARCHAR 这种类型也是多余的，因为 CHAR(6) 就可以很好的完成任务了。

同样的，如果可以的话，我们应该使用 MEDIUMINT 而不是 BIGIN 来定义整型字段，应该尽量把字段设置为 NOT NULL，这样在将来执行查询的时候，数据库不用去比较 NULL 值。

对于某些文本字段，例如“省份”或者“性别”，我们可以将它们定义为 ENUM 类型。因为在 MySQL 中，ENUM 类型被当作数值型数据来处理，而数值型数据被处理起来的速度要比文本类型快得多。这样，我们又可以提高数据库的性能。

#### 44、将大的DELETE，UPDATE、INSERT 查询变成多个小查询 ####

能写一个几十行、几百行的SQL语句是不是显得逼格很高？然而，为了达到更好的性能以及更好的数据控制，你可以将他们变成多个小查询。

#### 45、关于临时表 ####

（1）避免频繁创建和删除临时表，以减少系统表资源的消耗；

（2）在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log；

（3）如果数据量不大，为了缓和系统表的资源，应先create table，然后insert；

（4）如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除。先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

#### 46、使用explain分析你SQL执行计划 ####

（1）type

*  system：表仅有一行，基本用不到；
 *  const：表最多一行数据配合，主键查询时触发较多；
 *  eq\_ref：对于每个来自于前面的表的行组合，从该表中读取一行。这可能是最好的联接类型，除了const类型；
 *  ref：对于每个来自于前面的表的行组合，所有有匹配索引值的行将从这张表中读取；
 *  range：只检索给定范围的行，使用一个索引来选择行。当使用=、<>、>、>=、<、<=、IS NULL、<=>、BETWEEN或者IN操作符，用常量比较关键字列时，可以使用range；
 *  index：该联接类型与ALL相同，除了只有索引树被扫描。这通常比ALL快，因为索引文件通常比数据文件小；
 *  all：全表扫描；
 *  性能排名：system > const > eq\_ref > ref > range > index > all。
 *  实际sql优化中，最后达到ref或range级别。

（2）Extra常用关键字

*  Using index：只从索引树中获取信息，而不需要回表查询；
 *  Using where：WHERE子句用于限制哪一个行匹配下一个表或发送到客户。除非你专门从表中索取或检查所有行，如果Extra值不为Using where并且表联接类型为ALL或index，查询可能会有一些错误。需要回表查询。
 *  Using temporary：mysql常建一个临时表来容纳结果，典型情况如查询包含可以按不同情况列出列的GROUP BY和ORDER BY子句时；

#### 47、使用合理的分页方式以提高分页的效率 ####

select id,name from user limit 100000, 20

使用上述SQL语句做分页的时候，随着表数据量的增加，直接使用limit语句会越来越慢。

此时，可以通过取前一页的最大ID，以此为起点，再进行limit操作，效率提升显著。

select id,name from user where id> 100000 limit 20

#### 48、尽量控制单表数据量的大小，建议控制在500万以内 ####

500万并不是MySQL数据库的限制，过大会造成修改表结构，备份，恢复都会有很大的问题。

可以用历史数据归档（应用于日志数据），分库分表（应用于业务数据）等手段来控制数据量大小。

#### **49、谨慎使用Mysql分区表** ####

（1）分区表在物理上表现为多个文件，在逻辑上表现为一个表；

（2）谨慎选择分区键，跨分区查询效率可能更低；

（3）建议采用物理分表的方式管理大数据。

#### 50、尽量做到冷热数据分离，减小表的宽度 ####

Mysql限制每个表最多存储4096列，并且每一行数据的大小不能超过65535字节。

减少磁盘IO,保证热数据的内存缓存命中率（表越宽，把表装载进内存缓冲池时所占用的内存也就越大,也会消耗更多的IO）；

更有效的利用缓存，避免读入无用的冷数据；

经常一起使用的列放到一个表中（避免更多的关联操作）。

#### 51、禁止在表中建立预留字段 ####

（1）预留字段的命名很难做到见名识义；

（2）预留字段无法确认存储的数据类型，所以无法选择合适的类型；

（3）对预留字段类型的修改，会对表进行锁定；

#### 52、禁止在数据库中存储图片，文件等大的二进制数据 ####

通常文件很大，会短时间内造成数据量快速增长，数据库进行数据库读取时，通常会进行大量的随机IO操作，文件很大时，IO操作很耗时。

通常存储于文件服务器，数据库只存储文件地址信息。

#### 53、建议把BLOB**或是TEXT列分离到单独的扩展表中** ####

Mysql内存临时表不支持TEXT、BLOB这样的大数据类型，如果查询中包含这样的数据，在排序等操作时，就不能使用内存临时表，必须使用磁盘临时表进行。而且对于这种数据，Mysql还是要进行二次查询，会使sql性能变得很差，但是不是说一定不能使用这样的数据类型。

如果一定要使用，建议把BLOB或是TEXT列分离到单独的扩展表中，查询时一定不要使用select \* 而只需要取出必要的列，不需要TEXT列的数据时不要对该列进行查询。

#### 54、TEXT或BLOB类型只能使用前缀索引 ####

因为MySQL对索引字段长度是有限制的，所以TEXT类型只能使用前缀索引，并且TEXT列上是不能有默认值的。

#### 55、建议使用预编译语句进行数据库操作 ####

预编译语句可以重复使用这些计划，减少SQL编译所需要的时间，还可以解决动态SQL所带来的SQL注入的问题。

只传参数，比传递SQL语句更高效。

相同语句可以一次解析，多次使用，提高处理效率。

#### 56、表连接不宜太多，索引不宜太多，一般5个以内 ####

（1）表连接不宜太多，一般5个以内

*  关联的表个数越多，编译的时间和开销也就越大
 *  每次关联内存中都生成一个临时表
 *  应该把连接表拆开成较小的几个执行，可读性更高
 *  如果一定需要连接很多表才能得到数据，那么意味着这是个糟糕的设计了
 *  阿里规范中，建议多表联查三张表以下

（2）索引不宜太多，一般5个以内

*  索引并不是越多越好，虽其提高了查询的效率，但却会降低插入和更新的效率；
 *  索引可以理解为一个就是一张表，其可以存储数据，其数据就要占空间；
 *  索引表的数据是排序的，排序也是要花时间的；
 *  insert或update时有可能会重建索引，如果数据量巨大，重建将进行记录的重新排序，所以建索引需要慎重考虑，视具体情况来定；
 *  一个表的索引数最好不要超过5个，若太多需要考虑一些索引是否有存在的必要；

#### **57、数据库和表的字符集统一使用UTF8** ####

兼容性更好，统一字符集可以避免由于字符集转换产生的乱码，不同的字符集进行比较前需要进行转换会造成索引失效，如果数据库中有存储emoji表情的需要，字符集需要采用utf8mb4字符集。

#### 58、合理选择索引列的顺序 ####

建立索引的目的是：

希望通过索引进行数据查找，减少随机IO，增加查询性能 ，索引能过滤出越少的数据，则从磁盘中读入的数据也就越少。

区分度最高的放在联合索引的最左侧（区分度=列中不同值的数量/列的总行数）。

尽量把字段长度小的列放在联合索引的最左侧（因为字段长度越小，一页能存储的数据量越大，IO性能也就越好）。

使用最频繁的列放到联合索引的左侧（这样可以比较少的建立一些索引）。

#### 59、对于频繁的查询优先考虑使用覆盖索引 ####

覆盖索引：就是包含了所有查询字段(where,select,ordery by,group by包含的字段)的索引。

覆盖索引的好处：

（1）避免Innodb表进行索引的二次查询

Innodb是以聚集索引的顺序来存储的，对于Innodb来说，二级索引在叶子节点中所保存的是行的主键信息，如果是用二级索引查询数据的话，在查找到相应的键值后，还要通过主键进行二次查询才能获取我们真实所需要的数据。

而在覆盖索引中，二级索引的键值中可以获取所有的数据，避免了对主键的二次查询 ，减少了IO操作，提升了查询效率。

（2）可以把随机IO变成顺序IO加快查询效率

由于覆盖索引是按键值的顺序存储的，对于IO密集型的范围查找来说，对比随机从磁盘读取每一行的数据IO要少的多，因此利用覆盖索引在访问时也可以把磁盘的随机读取的IO转变成索引查找的顺序IO。

#### 60、MySQL 查询优化的一般策略： ####

使用慢查询日志去发现慢查询，使用执行计划去判断查询是否正常运行，总是去测试你的查询看看是否他们运行在最佳状态下。

久而久之性能总会变化，避免在整个表上使用 count(\*)，它可能锁住整张表，使查询保持一致以便后续相似的查询可以使用查询缓存，在适当的情形下使用 GROUP BY 而不是 DISTINCT，在 WHERE、GROUP BY 和 ORDER BY 子句中使用有索引的列，保持索引简单，不在多个索引中包含同一个列。

有时候 MySQL 会使用错误的索引，对于这种情况使用 USE INDEX，检查使用 SQL\_MODE=STRICT 的问题，对于记录数小于5的索引字段，在 UNION 的时候使用LIMIT不是是用OR。

为了避免在更新之前进行一次 SELECT，使用 INSERT ON DUPLICATE KEY 或者 INSERT IGNORE；

不要用 UPDATE 去实现，不要使用 MAX；

使用索引字段和 ORDER BY子句 LIMIT M，N 实际上可以减缓查询在某些情况下，有节制地使用，在 WHERE 子句中使用 UNION 代替子查询，在重新启动的 MySQL，记得来温暖你的数据库，以确保数据在内存和查询速度快，考虑持久连接，而不是多个连接，以减少开销。

基准查询，包括使用服务器上的负载，有时一个简单的查询可以影响其他查询，当负载增加在服务器上，使用 SHOW PROCESSLIST 查看慢的和有问题的查询，在开发环境中产生的镜像数据中测试的所有可疑的查询。

#### 61、定期的进行 MySQL 数据库的备份： ####

前段时间，有小伙伴来找尼恩，说他的数据库被黑客挟持了，要支付1个比特币才能要回来，我问他有定期的备份了吗，他说没有。

MySQL 数据库的备份流程：

*  从二级复制服务器上进行备份；
 *  在进行备份期间停止复制，以避免在数据依赖和外键约束上出现不一致；
 *  彻底停止 MySQL，从数据库文件进行备份；
 *  如果使用 MySQL dump 进行备份，请同时备份二进制日志文件 – 确保复制没有中断；
 *  不要信任 LVM 快照，这很可能产生数据不一致，将来会给你带来麻烦；
 *  为了更容易进行单表恢复，以表为单位导出数据——如果数据是与其他表隔离的。
 *  当使用 mysqldump 时请使用 –opt；
 *  在备份之前检查和优化表；
 *  为了更快的进行导入，在导入时临时禁用外键约束。；
 *  为了更快的进行导入，在导入时临时禁用唯一性检测；
 *  在每一次备份后计算数据库，表以及索引的尺寸，以便更够监控数据尺寸的增长；
 *  通过自动调度脚本监控复制实例的错误和延迟；
 *  定期执行备份。

#### 62、分库分表与NOSqL结合使用 ####

当数据量达到一定的数量之后，限制数据库存储性能的就不再是数据库层面的优化就能够解决的；

这个时候往往采用的是读写分离与分库分表同时也会结合缓存一起使用，而这个时候数据库层面的优化只是基础。

一般的演进规则是：

*  读写分离适用于较小一些的数据量；
 *  分表适用于中等数据量；
 *  而分库与分表一般是结合着用，这就适用于大数据量的存储了，

这也是现在大型互联网公司解决数据存储的方法之一。

*尼恩备注：*

*  分库分表与NOSqL结合使用，一般建议 ElasticSearch+Hbase架构。
 *  **左手大数据，右手云原生**， 要掌握高并发架构达到技术自由， 大数据、云原生的技术必不可少。
 *  *具体请参考尼恩的3高架构笔记*

### P8大佬的MySQL数据库设计规范 ###

#### 一：库表设计规范 ####

以下所有规范会按照【高危】、【强制】、【建议】三个级别进行标注，遵守优先级从高到低。对于不满足【高危】和【强制】两个级别的设计，DBA会强制打回要求修改。

##### **1、库名规范** #####

1.  【强制】库的名称必须控制在32个字符以内，相关模块的表名与表名之间尽量提现join的关系，如user表和user\_login表。
2.  【强制】库的名称格式：业务系统名称\_子系统名，同一模块使用的表名尽量使用统一前缀。
3.  【强制】一般分库名称命名格式是库通配名\_编号，编号从0开始递增，比如wenda\_001以时间进行分库的名称格式是“库通配名\_时间”
4.  【强制】创建数据库时必须显式指定字符集，并且字符集只能是utf8或者utf8mb4。创建数据库SQL举例：create database db1 default character set utf8;。

##### **2、 表结构规范** #####

1.  【强制】表和列的名称必须控制在32个字符以内，表名只能使用字母、数字和下划线，一律小写。
2.  【强制】表名要求模块名强相关，如师资系统采用”sz”作为前缀，渠道系统采用”qd”作为前缀等。
3.  【强制】创建表时必须显式指定字符集为utf8或utf8mb4。
4.  【强制】创建表时必须显式指定表存储引擎类型，如无特殊需求，一律为InnoDB。当需要使用除InnoDB/MyISAM/Memory以外的存储引擎时，必须通过DBA审核才能在生产环境中使用。因为Innodb表支持事务、行锁、宕机恢复、MVCC等关系型数据库重要特性，为业界使用最多的MySQL存储引擎。而这是其他大多数存储引擎不具备的，因此首推InnoDB。
5.  【强制】建表必须有comment
6.  【建议】建表时关于主键：(1)强制要求主键为id，类型为int或bigint，且为auto\_increment(2)标识表里每一行主体的字段不要设为主键，建议设为其他字段如user\_id，order\_id等，并建立unique key索引（可参考cdb.teacher表设计）。因为如果设为主键且主键值为随机插入，则会导致innodb内部page分裂和大量随机I/O，性能下降。
7.  【建议】核心表（如用户表，金钱相关的表）必须有行数据的创建时间字段create\_time和最后更新时间字段update\_time，便于查问题。
8.  【建议】表中所有字段必须都是NOT NULL属性，业务可以根据需要定义DEFAULT值。因为使用NULL值会存在每一行都会占用额外存储空间、数据迁移容易出错、聚合函数计算结果偏差等问题。
9.  【建议】建议对表里的blob、text等大字段，垂直拆分到其他表里，仅在需要读这些对象的时候才去select。
10. 【建议】反范式设计：把经常需要join查询的字段，在其他表里冗余一份。如user\_name属性在user\_account，user\_login\_log等表里冗余一份，减少join查询。
11. 【强制】中间表用于保留中间结果集，名称必须以tmp\_开头\_  
    备份表用于备份或抓取源表快照，名称必须以bak\_开头。  
    中间表和备份表定期清理。
12. 【强制】对于超过100W行的大表进行alter table，必须经过DBA审核，并在业务低峰期执行。  
    因为alter table会产生表锁，期间阻塞对于该表的所有写入，对于业务可能会产生极大影响。

##### **3、 列数据类型优化** #####

1.  【建议】表中的自增列（auto\_increment属性），推荐使用bigint类型。因为无符号int存储范围为-2147483648~2147483647（大约21亿左右），溢出后会导致报错。
2.  【建议】业务中选择性很少的状态status、类型type等字段推荐使用tinytint或者smallint类型节省存储空间。
3.  【建议】业务中IP地址字段推荐使用int类型，不推荐用char(15)。因为int只占4字节，可以用如下函数相互转换，而char(15)占用至少15字节。一旦表数据行数到了1亿，那么要多用1.1G存储空间。 SQL：select inet\_aton(‘192.168.2.12’); select inet\_ntoa(3232236044); PHP: ip2long(‘192.168.2.12’); long2ip(3530427185);
4.  【建议】不推荐使用enum，set。 因为它们浪费空间，且枚举值写死了，变更不方便。推荐使用tinyint或smallint。
5.  【建议】不推荐使用blob，text等类型。它们都比较浪费硬盘和内存空间。在加载表数据时，会读取大字段到内存里从而浪费内存空间，影响系统性能。建议和PM、RD沟通，是否真的需要这么大字段。Innodb中当一行记录超过8098字节时，会将该记录中选取最长的一个字段将其768字节放在原始page里，该字段余下内容放在overflow-page里。不幸的是在compact行格式下，原始page和overflow-page都会加载。
6.  【建议】存储金钱的字段，建议用int，程序端乘以100和除以100进行存取。因为int占用4字节，而double占用8字节，空间浪费。
7.  【建议】文本数据尽量用varchar存储。因为varchar是变长存储，比char更省空间。MySQL server层规定一行所有文本最多存65535字节，因此在utf8字符集下最多存21844个字符，超过会自动转换为mediumtext字段。而text在utf8字符集下最多存21844个字符，mediumtext最多存224/3个字符，longtext最多存232个字符。一般建议用varchar类型，字符数不要超过2700。
8.  【建议】时间类型尽量选取timestamp。  
    因为datetime占用8字节，timestamp仅占用4字节，但是范围为1970-01-01 00:00:01到2038-01-01 00:00:00。更为高阶的方法，选用int来存储时间，使用SQL函数unix\_timestamp()和from\_unixtime()来进行转换。

详细存储大小参加下图：

![157481e8a1854ac3877e23736b6e44fd.png][]

##### **4、 索引设计** #####

1.  【强制】InnoDB表必须主键为id int/bigint auto\_increment,且主键值禁止被更新。
2.  【建议】主键的名称以“pk\_”开头，唯一键以“uk\_”或“uq\_”开头，普通索引以“idx\_”开头，一律使用小写格式，以表名/字段的名称或缩写作为后缀。
3.  【强制】InnoDB和MyISAM存储引擎表，索引类型必须为BTREE；MEMORY表可以根据需要选择HASH或者BTREE类型索引。
4.  【强制】单个索引中每个索引记录的长度不能超过64KB。
5.  【建议】单个表上的索引个数不能超过7个。
6.  【建议】在建立索引时，多考虑建立联合索引，并把区分度最高的字段放在最前面。如列userid的区分度可由select count(distinct userid)计算出来。
7.  【建议】在多表join的SQL里，保证被驱动表的连接列上有索引，这样join执行效率最高。
8.  【建议】建表或加索引时，保证表里互相不存在冗余索引。对于MySQL来说，如果表里已经存在key(a,b)，则key(a)为冗余索引，需要删除。

##### **5、 分库分表、分区表** #####

1.  【强制】分区表的分区字段（partition-key）必须有索引，或者是组合索引的首列。
2.  【强制】单个分区表中的分区（包括子分区）个数不能超过1024。
3.  【强制】上线前RD或者DBA必须指定分区表的创建、清理策略。
4.  【强制】访问分区表的SQL必须包含分区键。
5.  【建议】单个分区文件不超过2G，总大小不超过50G。建议总分区数不超过20个。
6.  【强制】对于分区表执行alter table操作，必须在业务低峰期执行。
7.  【强制】采用分库策略的，库的数量不能超过1024
8.  【强制】采用分表策略的，表的数量不能超过4096
9.  【建议】单个分表不超过500W行，ibd文件大小不超过2G，这样才能让数据分布式变得性能更佳。
10. 【建议】水平分表尽量用取模方式，日志、报表类数据建议采用日期进行分表。

##### **6、 字符集** #####

1.  【强制】数据库本身库、表、列所有字符集必须保持一致，为utf8或utf8mb4。
2.  【强制】前端程序字符集或者环境变量中的字符集，与数据库、表的字符集必须一致，统一为utf8。

#### 二： SQL编写规范 ####

![ed339e5552714f538bb34fc9f406e86d.png][]

##### **1、 DML语句** #####

1.  【强制】SELECT语句必须指定具体字段名称，禁止写成\*。因为select \*会将不该读的数据也从MySQL里读出来，造成网卡压力。且表字段一旦更新，但model层没有来得及更新的话，系统会报错。
2.  【强制】insert语句指定具体字段名称，不要写成insert into t1 values(…)，道理同上。
3.  【建议】insert into…values(XX),(XX),(XX)…。这里XX的值不要超过5000个。值过多虽然上线很很快，但会引起主从同步延迟。
4.  【建议】SELECT语句不要使用UNION，推荐使用UNION ALL，并且UNION子句个数限制在5个以内。因为union all不需要去重，节省数据库资源，提高性能。
5.  【建议】in值列表限制在500以内。例如select… where userid in(….500个以内…)，这么做是为了减少底层扫描，减轻数据库压力从而加速查询。
6.  【建议】事务里批量更新数据需要控制数量，进行必要的sleep，做到少量多次。
7.  【强制】事务涉及的表必须全部是innodb表。否则一旦失败不会全部回滚，且易造成主从库同步终端。
8.  【强制】写入和事务发往主库，只读SQL发往从库。
9.  【强制】除静态表或小表（100行以内），DML语句必须有where条件，且使用索引查找。
10. 【强制】生产环境禁止使用hint，如sql\_no\_cache，force index，ignore key，straight join等。  
    因为hint是用来强制SQL按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的，因此我们要相信MySQL优化器！
11. 【强制】where条件里等号左右字段类型必须一致，否则无法利用索引。
12. 【建议】SELECT|UPDATE|DELETE|REPLACE要有WHERE子句，且WHERE子句的条件必需使用索引查找。
13. 【强制】生产数据库中强烈不推荐大表上发生全表扫描，但对于100行以下的静态表可以全表扫描。查询数据量不要超过表行数的25%，否则不会利用索引。
14. 【强制】WHERE 子句中禁止只使用全模糊的LIKE条件进行查找，必须有其他等值或范围查询条件，否则无法利用索引。
15. 【建议】索引列不要使用函数或表达式，否则无法利用索引。如where length(name)='Admin’或where user\_id+2=10023。
16. 【建议】减少使用or语句，可将or语句优化为union，然后在各个where条件上建立索引。如where a=1 or b=2优化为where a=1… union …where b=2, key(a),key(b)。
17. 【建议】分页查询，当limit起点较高时，可先用过滤条件进行过滤。如select a,b,c from t1 limit 10000,20;优化为:select a,b,c from t1 where id>10000 limit 20;。

##### **2、 多表连接** #####

1.  【强制】禁止跨db的join语句。因为这样可以减少模块间耦合，为数据库拆分奠定坚实基础。
2.  【强制】禁止在业务的更新类SQL语句中使用join，比如update t1 join t2…。
3.  【建议】不建议使用子查询，建议将子查询SQL拆开结合程序多次查询，或使用join来代替子查询。
4.  【建议】线上环境，多表join不要超过3个表。
5.  【建议】多表连接查询推荐使用别名，且SELECT列表中要用别名引用字段，数据库.表格式，如select a from db1.table1 alias1 where …。
6.  【建议】在多表join中，尽量选取结果集较小的表作为驱动表，来join其他表。

##### **3、 事务** #####

1.  【建议】事务中INSERT|UPDATE|DELETE|REPLACE语句操作的行数控制在2000以内，以及WHERE子句中IN列表的传参个数控制在500以内。
2.  【建议】批量操作数据时，需要控制事务处理间隔时间，进行必要的sleep，一般建议值5-10秒。
3.  【建议】对于有auto\_increment属性字段的表的插入操作，并发需要控制在200以内。
4.  【强制】程序设计必须考虑“数据库事务隔离级别”带来的影响，包括脏读、不可重复读和幻读。线上建议事务隔离级别为repeatable-read。
5.  【建议】事务里包含SQL不超过5个（支付业务除外）。因为过长的事务会导致锁数据较久，MySQL内部缓存、连接消耗过多等雪崩问题。
6.  【建议】事务里更新语句尽量基于主键或unique key，如update … where id=XX; 否则会产生间隙锁，内部扩大锁定范围，导致系统性能下降，产生死锁。
7.  【建议】尽量把一些典型外部调用移出事务，如调用webservice，访问文件存储等，从而避免事务过长。
8.  【建议】对于MySQL主从延迟严格敏感的select语句，请开启事务强制访问主库。

##### **4、 排序和分组** #####

1.  【建议】减少使用order by，和业务沟通能不排序就不排序，或将排序放到程序端去做。order by、group by、distinct这些语句较为耗费CPU，数据库的CPU资源是极其宝贵的。
2.  【建议】order by、group by、distinct这些SQL尽量利用索引直接检索出排序好的数据。如where a=1 order by可以利用key(a,b)。
3.  【建议】包含了order by、group by、distinct这些查询的语句，where条件过滤出来的结果集请保持在1000行以内，否则SQL会很慢。

##### **5、 线上禁止使用的SQL语句** #####

1.  【高危】禁用update|delete t1 … where a=XX limit XX; 这种带limit的更新语句。因为会导致主从不一致，导致数据错乱。建议加上order by PK。
2.  【高危】禁止使用关联子查询，如update t1 set … where name in(select name from user where…);效率极其低下。
3.  【强制】禁用procedure、function、trigger、views、event、外键约束。因为他们消耗数据库资源，降低数据库实例可扩展性。推荐都在程序端实现。
4.  【强制】禁用insert into …on duplicate key update…在高并发环境下，会造成主从不一致。
5.  【强制】禁止联表更新语句，如update t1,t2 where t1.id=t2.id…。

#### 40岁老架构师尼恩提示 ####

这里结合咱们社群中几个P8大佬的优化策略，统一为两大部分：

*  P8大佬的62条 SQL语句性能优化策略
 *  P8大佬的MySQL数据库设计规范

在面试之前，也可以复习一下，使得大家可以充分展示一下大家雄厚的 “技术肌肉”，**让面试官爱到 “不能自已、口水直流”**。

如果面试问到，mysql如何调优，可以按照上面的套路去作答，问题回答到这里，已经20分钟过去了，面试官已经爱到 “不能自已、口水直流” 啦。

以上内容，后面会不断更新， 会收入最新版本的《[尼恩Java面试宝典][Java]》

### 推荐阅读： ###

《[吃透8图1模板，人人可以做架构][8_1]》

《[干翻 nio ，王炸 io\_uring 来了 ！！（图解+史上最全）][nio _ io_uring _]》

《[SpringCloud+Dubbo3 = 王炸 ！][SpringCloud_Dubbo3 _ _]》

《[响应式圣经：10W字，实现Spring响应式编程自由][10W_Spring]》

《[4次迭代，让我的 Client 优化 100倍！泄漏一个 人人可用的极品方案！][4_ Client _ 100_]》

《[100亿级订单怎么调度，来一个大厂的极品方案][100]》

《[Linux命令大全：2W多字，一次实现Linux自由][Linux_2W_Linux]》

《[阿里一面：你做过哪些代码优化？来一个人人可以用的极品案例][Link 2]》

《[网易二面：CPU狂飙900%，该怎么处理？][CPU_900]》

《[阿里二面：千万级、亿级数据，如何性能优化？ 教科书级 答案来了][Link 3]》

《[峰值21WQps、亿级DAU，小游戏《羊了个羊》是怎么架构的？][21WQps_DAU]》

《[场景题：假设10W人突访，你的系统如何做到不 雪崩？][10W_]》

《[2个大厂 100亿级 超大流量 红包 架构方案][2_ 100_ _ _]》

《[Nginx面试题（史上最全 + 持续更新）][Nginx_ _]》

《[K8S面试题（史上最全 + 持续更新）][K8S_ _]》

《[操作系统面试题（史上最全、持续更新）][Link 4]》

《[Docker面试题（史上最全 + 持续更新）][Docker_ _]》

《[Springcloud gateway 底层原理、核心实战 (史上最全)][Springcloud gateway _]》

《[Flux、Mono、Reactor 实战（史上最全）][Flux_Mono_Reactor]》

《[sentinel （史上最全）][sentinel]》

《[Nacos (史上最全)][Nacos]》

《[TCP协议详解 (史上最全)][TCP_]》

《[分库分表 Sharding-JDBC 底层原理、核心实战（史上最全）][Sharding-JDBC]》

《[clickhouse 超底层原理 + 高可用实操 （史上最全）][clickhouse _ _ _]》

《[nacos高可用（图解+秒懂+史上最全）][nacos]》

《[队列之王： Disruptor 原理、架构、源码 一文穿透][Disruptor _]》

《[环形队列、 条带环形队列 Striped-RingBuffer （史上最全）][_ Striped-RingBuffer]》

《[一文搞定：SpringBoot、SLF4j、Log4j、Logback、Netty之间混乱关系（史上最全）][SpringBoot_SLF4j_Log4j_Logback_Netty]》

《[单例模式（史上最全）][Link 5]》

《[红黑树（ 图解 + 秒懂 + 史上最全）][_ _ _ _]》

《[分布式事务 （秒懂）][Link 6]》

《[缓存之王：Caffeine 源码、架构、原理（史上最全，10W字 超级长文）][Caffeine _10W_]》

《[缓存之王：Caffeine 的使用（史上最全）][Caffeine]》

《[Java Agent 探针、字节码增强 ByteBuddy（史上最全）][Java Agent _ ByteBuddy]》

《[Docker原理（图解+秒懂+史上最全）][Docker]》

《[Redis分布式锁（图解 - 秒懂 - 史上最全）][Redis_ - _ -]》

《[Zookeeper 分布式锁 - 图解 - 秒懂][Zookeeper _ - _ -]》

《[Zookeeper Curator 事件监听 - 10分钟看懂][Zookeeper Curator _ - 10]》

《[Netty 粘包 拆包 | 史上最全解读][Netty _ _ _]》

《[Netty 100万级高并发服务器配置][Netty 100]》

《[Springcloud 高并发 配置 （一文全懂）][Springcloud _ _]》

[Java]: https://blog.csdn.net/crazymakercircle/article/details/124790425
[Link 1]: https://gitee.com/crazymaker/SimpleCrayIM/blob/master/%E7%96%AF%E7%8B%82%E5%88%9B%E5%AE%A2%E5%9C%88%E6%80%BB%E7%9B%AE%E5%BD%95.md
[20200330211824877.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/c2187adb54ac4cdea329145991385a75.png
[157481e8a1854ac3877e23736b6e44fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f0ecf75a8b6a4f1489806dfe39b24ba6.png
[ed339e5552714f538bb34fc9f406e86d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a4d1b5bd124248b981f955b9ecc45fba.png
[8_1]: https://blog.csdn.net/crazymakercircle/article/details/129204455
[nio _ io_uring _]: https://blog.csdn.net/crazymakercircle/article/details/129190222
[SpringCloud_Dubbo3 _ _]: https://blog.csdn.net/crazymakercircle/article/details/129155538
[10W_Spring]: https://blog.csdn.net/crazymakercircle/article/details/129022714
[4_ Client _ 100_]: https://blog.csdn.net/crazymakercircle/article/details/129117619
[100]: https://blog.csdn.net/crazymakercircle/article/details/129145200
[Linux_2W_Linux]: https://blog.csdn.net/crazymakercircle/article/details/128932396
[Link 2]: https://blog.csdn.net/crazymakercircle/article/details/129056726
[CPU_900]: https://blog.csdn.net/crazymakercircle/article/details/128805374
[Link 3]: https://blog.csdn.net/crazymakercircle/article/details/128848309
[21WQps_DAU]: https://blog.csdn.net/crazymakercircle/article/details/128725701
[10W_]: https://blog.csdn.net/crazymakercircle/article/details/128533821
[2_ 100_ _ _]: https://blog.csdn.net/crazymakercircle/article/details/128697096
[Nginx_ _]: https://blog.csdn.net/crazymakercircle/article/details/128684641
[K8S_ _]: https://blog.csdn.net/crazymakercircle/article/details/128671196
[Link 4]: https://blog.csdn.net/crazymakercircle/article/details/128708648
[Docker_ _]: https://blog.csdn.net/crazymakercircle/article/details/128670335
[Springcloud gateway _]: https://blog.csdn.net/crazymakercircle/article/details/125057567
[Flux_Mono_Reactor]: https://blog.csdn.net/crazymakercircle/article/details/124120506
[sentinel]: https://blog.csdn.net/crazymakercircle/article/details/125059491
[Nacos]: https://blog.csdn.net/crazymakercircle/article/details/125057545
[TCP_]: https://blog.csdn.net/crazymakercircle/article/details/114527369
[Sharding-JDBC]: https://blog.csdn.net/crazymakercircle/article/details/123420859
[clickhouse _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/126992542
[nacos]: https://blog.csdn.net/crazymakercircle/article/details/120702536
[Disruptor _]: https://blog.csdn.net/crazymakercircle/article/details/128264803
[_ Striped-RingBuffer]: https://blog.csdn.net/crazymakercircle/article/details/128264508
[SpringBoot_SLF4j_Log4j_Logback_Netty]: https://blog.csdn.net/crazymakercircle/article/details/125135726
[Link 5]: https://blog.csdn.net/crazymakercircle/article/details/128265067
[_ _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/125017316
[Link 6]: https://blog.csdn.net/crazymakercircle/article/details/109459593
[Caffeine _10W_]: https://blog.csdn.net/crazymakercircle/article/details/128123114
[Caffeine]: https://blog.csdn.net/crazymakercircle/article/details/113751575
[Java Agent _ ByteBuddy]: https://blog.csdn.net/crazymakercircle/article/details/126579528
[Docker]: https://blog.csdn.net/crazymakercircle/article/details/120747767
[Redis_ - _ -]: https://blog.csdn.net/crazymakercircle/article/details/116425814
[Zookeeper _ - _ -]: https://blog.csdn.net/crazymakercircle/article/details/85956246
[Zookeeper Curator _ - 10]: https://blog.csdn.net/crazymakercircle/article/details/85922561
[Netty _ _ _]: https://blog.csdn.net/crazymakercircle/article/details/83957259
[Netty 100]: https://blog.csdn.net/crazymakercircle/article/details/83758107
[Springcloud _ _]: https://blog.csdn.net/crazymakercircle/article/details/102557988