《mysql45讲》基础篇总结-ag真人游戏

目录结构：

极客时间：林晓斌老师的mysql45讲学习笔记。

根据基础篇的内容总结归纳为几部分，分类整理，并添加许多自定义的图片，看完后对mysql的结构、日志系统、事务、索引、锁。会有新的认识。目前已有基础篇，还会持续更新…

mysql构成

mysql分为server层和存储引擎两层。

一个查询语句的执行流程：

mysql> select * from t where id=10;

连接器

建立连接

首先，你会连接到这个数据库上，连接器负责跟客户端简历连接，获取权限，维持和管理连接。

连接命令一般这么写：

mysql -h$ip -p$port -u$user -p

mysql：客户端工具，用来跟服务端建立连接，完成tcp握手后，连接器开始认证身份(用户名密码)。
如果验证通过：连接器到权限表里查出账号拥有的权限。如果验证不通过，返回错误，并且客户端程序结束执行。

这也就意味着，一个用户建立连接后，即使管理员对此用户修改权限，也不会影响已经存在的连接权限，只有从新建立连接才会影响权限。

连接成功后

连接完成后，如果你没有后续的动作，这个连接就处于空闲状态，你可以在show processlist命令中看到它。文本中这个图是show processlist的结果，其中的command列显示为“sleep”的这一行，就表示现在系统里面有一个空闲连接。

断开连接

客户端如果太长时间没有动静，连接器就会自动将它断开，这个时间是由wait_timeout控制的，默认是8小时。

长链接和短连接

数据库里面，长连接是指连接成功后，如果客户端持续有请求，则一直使用同一个连接。

短连接则是指每次执行完很少的几次查询就断开连接，下次查询再重新建立一个。

连接方案的选择

建立连接的过程通常是比较复杂的，所以我建议你在使用中要尽量减少建立连接的动作，也就是尽量使用长连接。

但是全部使用长连接后，你可能会发现，有些时候mysql占用内存涨得特别快，这是因为mysql在执行过程中临时使用的内存是管理在连接对象里面的。这些资源会在连接断开的时候才释放。所以如果长连接累积下来，可能导致内存占用太大，被系统强行杀掉（oom），从现象看就是mysql异常重启了。

怎么解决这个问题呢？你可以考虑以下两种方案。

定期断开长连接。使用一段时间，或者程序里面判断执行过一个占用内存的大查询后，断开连接，之后要查询再重连。
如果你用的是mysql 5.7或更新版本，**可以在每次执行一个比较大的操作后，通过执行 mysql_reset_connection来重新初始化连接资源。**这个过程不需要重连和重新做权限验证，但是会将连接恢复到刚刚创建完时的状态。

查询缓存

查询缓存的操作一般是利大于弊，查询缓存的失效非常频繁，只要有对一个表的更新，这个表上所有的查询缓存都会被清空。除非你的业务就是有一张静态表，很长时间才会更新一次。比如，一个系统配置表，那这张表上的查询才适合使用查询缓存。

分析器

首先，mysql需要知道你要做什么，因此需要对sql语句做解析。

词法分析

你输入的是由多个字符串和空格组成的一条sql语句，mysql需要识别出里面的字符串分别是什么，代表什么。

mysql从你输入的"select"这个关键字识别出来，这是一个查询语句。它也要把字符串“t”识别成“表名t”，把字符串“id”识别成“列id”,判断列是否存在，表是否存在。

语法分析

根据词法分析的结果，语法分析器会根据语法规则，判断你输入的这个sql语句是否满足mysql语法。

如果你的语句不对，就会收到you have an error in your sql syntax的错误提醒。

优化器

经过了分析器，mysql就知道要做什么了，在开始执行之前，还要先经过优化器的处理。

优化器的功能包括：

选择合适的索引
决定各个表的连接顺序

执行器

mysql通过分析器知道了你要做什么，通过优化器知道了要怎么做，于是就进入了执行器阶段，开始执行语句。

检查是否有权限
扫描存储引擎，找到响应的数据。

课后题:

1.我给你留一个问题吧，如果表t中没有字段k，而你执行了这个语句 select * from t where k=1, 那肯定是会报“不存在这个列”的错误： “unknown column ‘k’ in ‘where clause’”。你觉得这个错误是在我们上面提到的哪个阶段报出来的呢？

分析器，分析器中判断语句是否正确，表是否存在，列是否存在。

mysql的日志系统

redo log 用于保证 crash-safe 能力。innodb_flush_log_at_trx_commit 这个参数设置成1 的时候，表示每次事务的 redo log 都直接持久化到磁盘。这个参数我建议你设置成 1，
这样可以保证 mysql 异常重启之后数据不丢失。
sync_binlog 这个参数设置成 1 的时候，表示每次事务的 binlog 都持久化到磁盘。这个参数我也建议你设置成 1，这样可以保证 mysql 异常重启之后 binlog 不丢失。

redo log(重做日志)

简介：

redo log 是 innodb 引擎特有的日志

《孔乙己》的例子：

酒店掌柜有一个粉板，专门用来记录客人的赊账记录。如果赊账的人不多，那么他可以把顾客名和账目写在板上。但如果赊账的人多了，粉板总会有记不下的时候，这个时候掌柜一定还有一个专门记录赊账的账本。

如果有人要赊账或者还账的话，掌柜一般有两种做法：

一种做法是直接把账本翻出来，把这次赊的账加上去或者扣除掉；
另一种做法是先在粉板上记下这次的账，等打烊以后再把账本翻出来核算。

在生意红火柜台很忙时，掌柜一定会选择后者，因为前者操作实在是太麻烦了。首先，你得找到这个人的赊账总额那条记录。你想想，密密麻麻几十页，掌柜要找到那个名字，可能还得带上老花镜慢慢找，找到之后再拿出算盘计算，最后再将结果写回到账本上。

redo log不是记录数据页“更新之后的状态”，而是记录这个页 “做了什么改动”。

wal

在mysql中如果每次更新操作都要写进磁盘，然后磁盘也要找到那条记录再更新，整个io成本、查找成本都很高，为了解决这个问题，mysql的设计者就用到了类似孔乙己中粉板的思路来提升更新效率。

而粉板和账本配合的整个过程，其实就是mysql里经常说到的wal技术，wal的全称是write-ahead logging，它的关键点就是先写日志，再写磁盘，也就是先写粉板(日志)，等不忙的时候再写账本(磁盘)。

有了redo log，innodb就可以保证即使数据库发生异常重启，之前提交的记录都不会丢失，这个能力称为crash-safe(碰撞安全)。

两阶段提交

两阶段提交是跨系统维持数据逻辑一致性时常用的一个方案

将redo log的写入拆成了两个步骤：prepare和commit，这就是"两阶段提交"。(参考更新语句执行流程)

为什么必须有“两阶段提交”呢？

由于redo log和binlog是两个独立的逻辑，如果不用两阶段提交，要么就是先写完redo log再写binlog，或者采用反过来的顺序。我们看看这两种方式会有什么问题。

仍然用前面的update语句来做例子。假设当前id=2的行，字段c的值是0，再假设执行update语句过程中在写完第一个日志后，第二个日志还没有写完期间发生了crash，会出现什么情况呢？

先写redo log后写binlog。假设在redo log写完，binlog还没有写完的时候，mysql进程异常重启。由于我们前面说过的，redo log写完之后，系统即使崩溃，仍然能够把数据恢复回来，所以恢复后这一行c的值是1。
但是由于binlog没写完就crash了，这时候binlog里面就没有记录这个语句。因此，之后备份日志的时候，存起来的binlog里面就没有这条语句。
然后你会发现，如果需要用这个binlog来恢复临时库的话，由于这个语句的binlog丢失，这个临时库就会少了这一次更新，恢复出来的这一行c的值就是0，与原库的值不同。
先写binlog后写redo log。如果在binlog写完之后crash，由于redo log还没写，崩溃恢复以后这个事务无效，所以这一行c的值是0。但是binlog里面已经记录了“把c从0改成1”这个日志。所以，在之后用binlog来恢复的时候就多了一个事务出来，恢复出来的这一行c的值就是1，与原库的值不同。

可以看到，如果不使用“两阶段提交”，那么数据库的状态就有可能和用它的日志恢复出来的库的状态不一致。

undo log(回滚日志)

在mysql中，实际上每条记录在更新的时候都会同时记录一条回滚操作。记录上的最新值，通过回滚操作，都可以得到前一个状态的值。

当进行数据修改时还会记录undo log，undo log用于数据的撤回操作，它保留了记录修改前的内容。通过undo log可以实现事务回滚，并且可以根据undo log回溯到某个特定的版本的
数据，实现mvcc。

binlog(归档日志)

binlog是server层的日志

二进制日志（bin log）是mysql数据库级别的文件，记录对mysql数据库执行修改的所有操作，不会记录select和show语句，主要用于恢复数据库和同步数据库。

日志的区别

redo log与binlog的区别

redo log是innodb引擎特有的；binlog是mysql的server层实现的，所有引擎都可以使用。
redo log是物理日志，记录的是“在某个数据页上做了什么修改”；binlog是逻辑日志，记录的是这个语句的原始逻辑，比如“给id=2这一行的c字段加1 ”。
redo log是循环写的，空间固定会用完；binlog是可以追加写入的。“追加写”是指binlog文件写到一定大小后会切换到下一个，并不会覆盖以前的日志。

更新语句的执行流程

通过一个更新语句的流程，分析日志系统。

mysql>update t set c=c 1 where id=2;

执行流程：

首先连接器连接数据库
分析器通过词法，语法分析发现这是一条更新语句
优化器决定使用id这个索引
执行器找引擎取id=2的这行数据。id是主键，引擎用索引找到这一行，如果这一行数据本来就在内存中，直接返回给执行器，否则需要从磁盘读入内存。
执行器拿到数据后。把这个数据的c 1,得到一行新的数据，再调用引擎接口写入这行新数据。
引擎将这个数据更新到内存中，同时将这个更新操作记录在redo log, 此时redo log 处于prepare(准备)状态，告知执行器执行完成了，可以随时提交事务。
执行器生成这个操作的binlog,并将binlog写入磁盘。
执行器调用存储引擎的提交事务接口，引擎把刚刚写入的redo log改成commit(提交)状态，更新完成。

图中浅色框表示是在innodb内部执行的，深色框表示是在执行器中执行的。

mysql的事务

acid（atomicity、consistency、isolation、durability，即原子性、一致性、隔离性、持久性）

简单来说，事务就是要保证一组数据库操作，要么全部成功，要么全部失败。在mysql中，事务支持是在引擎层实现的。

启动事务的几种方式

mysql的事务启动方式有以下几种：

显式启动事务语句， begin 或 start transaction。配套的提交语句是commit，回滚语句是rollback。
set autocommit=0，这个命令会将这个线程的自动提交关掉。意味着如果你只执行一个select语句，这个事务就启动了，而且并不会自动提交。这个事务持续存在直到你主动执行commit 或 rollback 语句，或者断开连接。

有些客户端连接框架会默认连接成功后先执行一个set autocommit=0的命令。这就导致接下来的查询都在事务中，如果是长连接，就导致了意外的长事务。

因此，我会建议你总是使用set autocommit=1, 通过显式语句的方式来启动事务。

但是有的开发同学会纠结“多一次交互”的问题。对于一个需要频繁使用事务的业务，第二种方式每个事务在开始时都不需要主动执行一次 “begin”，减少了语句的交互次数。如果你也有这个顾虑，我建议你使用commit work and chain语法。

在autocommit为1的情况下，用begin显式启动的事务，如果执行commit则提交事务。如果执行 commit work and chain，则是提交事务并自动启动下一个事务，这样也省去了再次执行begin语句的开销。同时带来的好处是从程序开发的角度明确地知道每个语句是否处于事务中。

事务隔离

隔离性和隔离级别

当数据库上有多个事务同时执行的时候，就可能出现脏读（dirty read）、不可重复读（non-repeatable read）、幻读（phantom read）的问题，为了解决这些问题，就有了“隔离级别”的概念。

在谈隔离级别之前，你首先要知道，==你隔离得越严实，效率就会越低。==因此很多时候，我们都要在二者之间寻找一个平衡点。sql标准的事务隔离级别包括：读未提交（read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（serializable ）。下面我逐一为你解释：

读未提交是指，一个事务还没提交时，它做的变更就能被别的事务看到。
读提交是指，一个事务提交之后，它做的变更才会被其他事务看到。（其他事务提交后，就能读到修改）
可重复读是指，一个事务执行过程中看到的数据，总是跟这个事务在启动时看到的数据是一致的。当然在可重复读隔离级别下，未提交变更对其他事务也是不可见的。(以自己的事务为准，只有自己的事务提交了，才能读到其他事务的修改)

应用场景：

假设你在管理一个个人银行账户表。一个表存了每个月月底的余额，一个表存了账单明细。这时候你要做数据校对，也就是判断上个月的余额和当前余额的差额，是否与本月的账单明细一致。你一定希望在校对过程中，即使有用户发生了一笔新的交易，也不影响你的校对结果。

串行化，顾名思义是对于同一行记录，“写”会加“写锁”，“读”会加“读锁”。当出现读写锁冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行。

事务隔离的实现

查看、修改数据库的隔离级别：

查看：

select @@transaction_isolation;

修改隔离级别：

set {
  session | global} transaction isolation level {
  read uncommitted | read committed | repeatable read | serializable};
-- session: 为当前会话
-- global: 为本次连接所有会话
-- 例子：设置当前会话的事务隔离级别为提交读(`read committed`)  
set session transaction isolation level read committed;

无论是 session 还是 global 级别，断开 mysql 连接,下次再连接的时候,还是原来的事务隔离级别,因此彻底更新mysql 事务隔离级别，需要修改 mysql 配置文件

配置的方式是，将启动参数transaction-isolation的值设置成需要的隔离属性。

可以通过show variables like 'transaction_isolation';命令查看默认的隔离属性。（mysql隔离属性默认为可重复读，oracle数据库的默认隔离级别其实就是“读提交”）

隔离性如何实现的？

读未提交：直接返回记录上的最新值，不需要创建视图。；
读提交：每次sql语句执行的时候，创建一个视图。
可重复读：开启事务的时候创建一个视图，访问的时候以视图的逻辑结果为准。
串行化：通过加锁的方式避免并行访问。

展开分析可重复读：

假设一个值从1被按顺序改成了2、3、4，在回滚日志里面就会有类似下面的记录：

当前值是4，但是在查询这条记录的时候，不同时刻启动的事务会有不同的read-view。

在mysql里，有两个“视图”的概念：

一个是view。它是一个用查询语句定义的虚拟表，在调用的时候执行查询语句并生成结果。创建视图的语法是create view … ，而它的查询方法与表一样。
另一个是innodb在实现mvcc时用到的一致性读视图，即consistent read view，用于支持rc（read committed，读提交）和rr（repeatable read，可重复读）隔离级别的实现。

它没有物理结构，作用是事务执行期间用来定义“我能看到什么数据”。

mvcc

如图中看到的，在视图a、b、c里面，这一个记录的值分别是1、2、4，同一条记录在系统中可以存在多个版本，就是数据库的多版本并发控制（mvcc）。对于read-view a，要得到1，就必须将当前值依次执行图中所有的回滚操作得到。

长事务的弊端

什么是长事务

首先我们先要知道什么是长事务，顾名思义就是运行时间比较长，长时间未提交的事务，也可以称之为大事务。

长事务意味着系统里面会存在很老的事务视图。由于这些事务随时可能访问数据库里面的任何数据，所以这个事务提交之前，数据库里面它可能用到的回滚记录都必须保留，这就会导致大量占用存储空间。
除了对回滚段的影响，长事务还占用锁资源，也可能拖垮整个库

你可以在information_schema库的innodb_trx这个表中查询长事务，比如下面这个语句，用于查找持续时间超过60s的事务。

select * from information_schema.innodb_trx where time_to_sec(timediff(now(),trx_started))>60

问题：如何避免出现长事务

首先，从应用开发端来看：

确认是否使用了set autocommit=0。这个确认工作可以在测试环境中开展，把mysql的general_log开起来，然后随便跑一个业务逻辑，通过general_log的日志来确认。一般框架如果会设置这个值，也就会提供参数来控制行为，你的目标就是把它改成1。
确认是否有不必要的只读事务。有些框架会习惯不管什么语句先用begin/commit框起来。我见过有些是业务并没有这个需要，但是也把好几个select语句放到了事务中。这种只读事务可以去掉。
业务连接数据库的时候，根据业务本身的预估，通过set max_execution_time命令，来控制每个语句执行的最长时间，避免单个语句意外执行太长时间。（为什么会意外？在后续的文章中会提到这类案例）

其次，从数据库端来看：

监控 information_schema.innodb_trx表，设置长事务阈值，超过就报警/或者kill；
percona的pt-kill这个工具不错，推荐使用；
在业务功能测试阶段要求输出所有的general_log，分析日志行为提前发现问题；
如果使用的是mysql 5.6或者更新版本，把innodb_undo_tablespaces设置成2（或更大的值）。如果真的出现大事务导致回滚段过大，这样设置后清理起来更方便。

mysql索引

索引就像书的目录一样，索引的出现就是为了提高查询效率。

索引的常见模型

你现在维护着一个身份证信息和姓名的表，需要根据身份证号查找对应的名字

哈希表

好处：新增或者等值查询很快

缺点：因为是无序的所以区间查询的速度很慢，不支持范围查询，并且大数据量容易有hash冲突。

适用场景：等值查询，一些nosql的数据库引擎，比如memcached

有序数组

优点：有序数组在等值查询和范围查询场景中的性能就都非常优秀。如果仅仅看查询效率，有序数组就是最好的数据结构了

缺点：但是，在需要更新数据的时候就麻烦了，你往中间插入一个记录就必须得挪动后面所有的记录，成本太高。

适用场景：有序数组索引只适用于静态存储引擎，比如你要保存的是2017年某个城市的所有人口信息，这类不会再修改的数据。

平衡二叉搜索树(avl)

好处：搜索效率高

缺点：数据库存储不适用二叉树，数据过多会造成树过高。

数据库不适用原因：因为索引不止存在内存中，还要写在磁盘上，为了尽量少地读写磁盘，减少io次数，所以尽管二叉树的效率很高，大多数数据库不会选择二叉树。

n叉树

n叉树由于在读写上的性能优点，以及适配磁盘的访问模式，已经被广泛应用在数据库引擎中了。

以innodb的一个整数字段索引为例，这个n差不多是1200。这棵树高是4的时候，就可以存1200的3次方个值，这已经17亿了。考虑到树根的数据块总是在内存中的，一个10亿行的表上一个整数字段的索引，查找一个值最多只需要访问3次磁盘。其实，树的第二层也有很大概率在内存中，那么访问磁盘的平均次数就更少了。

innodb的索引模型

在innodb中，表都是根据主键顺序以索引的形式存放的，这种存储方式的表称为索引组织表。

每一个索引在innodb里面对应一棵b 树。

假设，我们有一个主键列为id的表，表中有字段k，并且在k上有索引。

这个表的建表语句是：

mysql> create table t(
id int primary key, 
k int not null, 
name varchar(16),
index (k))engine=innodb;

表中r1~r5的(id,k)值分别为(100,1)、(200,2)、(300,3)、(500,5)和(600,6)，两棵树的示例示意图如下。

主键索引的叶子节点存的是整行数据。在innodb里，主键索引也被称为聚簇索引（clustered index）。
非主键索引的叶子节点内容是主键的值。在innodb里，非主键索引也被称为二级索引（secondary index）。

基于主键索引和普通索引的查询有什么区别？

如果语句是select * from t where id=500，即主键查询方式，则只需要搜索id这棵b 树；
如果语句是select * from t where k=5，即普通索引查询方式，则需要先搜索k索引树，得到id的值为500，再到id索引树搜索一次。这个过程称为回表。

索引的维护

b 树为了维护索引有序性，在插入新值的时候需要做必要的维护。

如果插入新记录id为400，还需要挪动后面的数据，如果r5所在的数据也满了，还需要申请新的数据页，然后挪动部分数据过去，这个过程称为页分裂。

为什么需要自增主键？

自增主键是指自增列上定义的主键，在建表语句中一般是这么定义的： not null primary key auto_increment。

从性能和存储空间方面考量，自增主键往往是更合理的选择。

性能：

自增主键的插入数据模式，正符合了递增插入的场景。每次插入一条新记录，都是追加操作，都不涉及到挪动其他记录，也不会触发叶子节点的分裂。
而有业务逻辑的字段做主键，则往往不容易保证有序插入，这样写数据成本相对较高。

存储：

由于每个非主键索引的叶子节点上都是主键的值。如果用身份证号做主键，那么每个二级索引的叶子节点占用约20个字节，而如果用整型做主键，则只要4个字节，如果是长整型（bigint）则是8个字节。
主键长度越小，普通索引的叶子节点就越小，普通索引占用的空间也就越小。

什么时候用业务字段作为主键？？

只有一个索引；
该索引必须是唯一索引。

你一定看出来了，这就是典型的kv场景。

由于没有其他索引，所以也就不用考虑其他索引的叶子节点大小的问题。

这时候我们就要优先考虑上一段提到的“尽量使用主键查询”原则，直接将这个索引设置为主键，可以避免每次查询需要搜索两棵树。

索引的优化

由于查询结果所需要的数据只在主键索引上有，所以不得不回表。那么，有没有可能经过索引优化，避免回表过程呢？

例如查询语句:select * from t where k between 3 and 5

覆盖索引

如果执行的语句是select id from t where k between 3 and 5，这时只需要查id的值，而id的值已经在k索引树上了，因此可以直接提供查询结果，不需要回表。也就是说，在这个查询里面，索引k已经“覆盖了”我们的查询需求，我们称为覆盖索引。

由于覆盖索引可以减少树的搜索次数，显著提升查询性能，所以使用覆盖索引是一个常用的性能优化手段。

应用场景：

在一个市民信息表上，是否有必要将身份证号和名字建立联合索引？

假设这个市民表的定义是这样的：

create table `tuser` (
  `id` int(11) not null,
  `id_card` varchar(32) default null,
  `name` varchar(32) default null,
  `age` int(11) default null,
  `ismale` tinyint(1) default null,
  primary key (`id`),
  key `id_card` (`id_card`),
  key `name_age` (`name`,`age`)
) engine=innodb

我们知道，身份证号是市民的唯一标识。也就是说，如果有根据身份证号查询市民信息的需求，我们只要在身份证号字段上建立索引就够了。而再建立一个（身份证号、姓名）的联合索引，是不是浪费空间？

如果现在有一个高频请求，要根据市民的身份证号查询他的姓名，这个联合索引就有意义了。它可以在这个高频请求上用到覆盖索引，不再需要回表查整行记录，减少语句的执行时间。

当然，索引字段的维护总是有代价的。因此，在建立冗余索引来支持覆盖索引时就需要权衡考虑了。

最左前缀原则

如果为每一种查询都设计一个索引，索引是不是太多了。如果我现在要按照市民的身份证号去查他的家庭地址呢？虽然这个查询需求在业务中出现的概率不高，但总不能让它走全表扫描吧？反过来说，单独为一个不频繁的请求创建一个（身份证号，地址）的索引又感觉有点浪费。应该怎么做呢？

b 树这种索引结构，可以利用索引的“最左前缀”，来定位记录。

索引项是按照索引定义里面出现的字段顺序排序的。
如果你要查的是所有名字第一个字是“张”的人，你的sql语句的条件是"where name like ‘张%’"。这时，你也能够用上这个索引，查找到第一个符合条件的记录是id3，然后向后遍历，直到不满足条件为止。
可以看到，不只是索引的全部定义，只要满足最左前缀，就可以利用索引来加速检索。这个最左前缀可以是联合索引的最左n个字段，也可以是字符串索引的最左m个字符。

联合索引

在建立联合索引的时候，如何安排索引内的字段顺序？

索引的复用能力。因为可以支持最左前缀，所以当已经有了(a,b)这个联合索引后，一般就不需要单独在a上建立索引了。因此，第一原则是，如果通过调整顺序，可以少维护一个索引，那么这个顺序往往就是需要优先考虑采用的。

如果既有联合查询，又有基于a、b各自的查询呢？查询条件里面只有b的语句，是无法使用(a,b)这个联合索引的，这时候你不得不维护另外一个索引，也就是说你需要同时维护(a,b)、(b) 这两个索引。

这时候，我们要考虑的原则就是空间了。比如上面这个市民表的情况，name字段是比age字段大的，那我就建议你创建一个（name,age)的联合索引和一个(age)的单字段索引。

索引下推

我们还是以市民表的联合索引（name, age）为例。如果现在有一个需求：检索出表中“名字第一个字是张，而且年龄是10岁的所有男孩”。那么，sql语句是这么写的：

mysql> select * from tuser where name like '张%' and age=10 and ismale=1;

你已经知道了前缀索引规则，所以这个语句在搜索索引树的时候，只能用 “张”，找到第一个满足条件的记录id3。当然，这还不错，总比全表扫描要好。

然后从id3开始一个个回表，到主键索引上找出数据行，再筛选。

这个过程innodb并不会去看age的值，只是按顺序把“name第一个字是’张’”的记录一条条取出来回表。因此，需要回表4次。

mysql5.6以后：可以在索引遍历过程中，对索引中包含的字段先做判断，直接过滤掉不满足条件的记录，减少回表次数。

索引下推后流程：

mysql的锁

今天我要跟你聊聊mysql的锁。数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。

根据加锁的范围，mysql里面的锁大致可以分成

全局锁
表级锁
行锁

全局锁

顾名思义，全局锁就是对整个数据库实例加锁。mysql提供了一个加全局读锁的方法，命令是 flush tables with read lock (ftwrl)。

当你需要让整个库处于只读状态的时候，可以使用这个命令，之后其他线程的以下语句会被阻塞：数据更新语句（数据的增删改）、数据定义语句（包括建表、修改表结构等）和更新类事务的提交语句。

全局锁的典型使用场景是，做全库逻辑备份。

这种应用的弊端：

如果你在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆；
如果你在从库上备份，那么备份期间从库不能执行主库同步过来的binlog，会导致主从延迟。

如果不加锁备份会怎样？

假如在主从备份的时候，小王对主库中自己的余额进行充值， 1000；但是充值成功的前一刻正好从库备份完成，之后主库出现故障，通过备份恢复后，发现账户少了1000块钱。

也就是说，不加锁的话，备份系统备份的得到的库不是一个逻辑时间点，这个视图是逻辑不一致的。

那么，如何让视图的逻辑一致呢?(可以查阅事务篇——隔离级别)

在可重复读隔离级别下开启一个事务。官方自带的逻辑备份工具是mysqldump。当mysqldump使用参数–single-transaction的时候，导数据之前就会启动一个事务，来确保拿到一致性视图。而由于mvcc的支持，这个过程中数据是可以正常更新的。

single-transaction方法只适用于所有的表使用事务引擎的库。

全局锁和只读属性的区别

既然要全库只读，为什么不使用set global readonly=true的方式呢？确实readonly方式也可以让全库进入只读状态，但我还是会建议你用ftwrl方式，主要有两个原因：

一是，在有些系统中，readonly的值会被用来做其他逻辑，比如用来判断一个库是主库还是备库。因此，修改global变量的方式影响面更大，我不建议你使用。
二是，在异常处理机制上有差异。如果执行ftwrl命令之后由于客户端发生异常断开，那么mysql会自动释放这个全局锁，整个库回到可以正常更新的状态。而将整个库设置为readonly之后，如果客户端发生异常，则数据库就会一直保持readonly状态，这样会导致整个库长时间处于不可写状态，风险较高。

表级锁

mysql里面表级别的锁有两种：一种是表锁，一种是元数据锁（meta data lock，mdl)。

表锁

**表锁的语法是 lock tables … read/write。**与ftwrl类似，可以用unlock tables主动释放锁，也可以在客户端断开的时候自动释放。需要注意，lock tables语法除了会限制别的线程的读写外，也限定了本线程接下来的操作对象。

mdl(元数据锁)

mdl不需要显式使用，在访问一个表的时候会被自动加上。mdl的作用是，保证读写的正确性。你可以想象一下，如果一个查询正在遍历一个表中的数据，而执行期间另一个线程对这个表结构做变更，删了一列，那么查询线程拿到的结果跟表结构对不上，肯定是不行的。

因此，在mysql 5.5版本中引入了mdl，当对一个表做增删改查操作的时候，加mdl读锁；当要对表做结构变更操作的时候，加mdl写锁。

读锁之间不互斥，因此你可以有多个线程同时对一张表增删改查。
读写锁之间、写锁之间是互斥的，用来保证变更表结构操作的安全性。因此，如果有两个线程要同时给一个表加字段，其中一个要等另一个执行完才能开始执行。

虽然mdl锁是系统默认会加的，但却是你不能忽略的一个机制。

mdl会直到事务提交才释放，在做表结构变更的时候，你一定要小心不要导致锁住线上查询和更新。

如何安全地给小表加字段？

首先我们要解决长事务，事务不提交，就会一直占着mdl锁。在mysql的information_schema 库的 innodb_trx 表中，你可以查到当前执行中的事务。如果你要做ddl变更的表刚好有长事务在执行，要考虑先暂停ddl，或者kill掉这个长事务。

但考虑一下这个场景。如果你要变更的表是一个热点表，虽然数据量不大，但是上面的请求很频繁，而你不得不加个字段，你该怎么做呢？

这时候kill可能未必管用，因为新的请求马上就来了。比较理想的机制是，在alter table语句里面设定等待时间，如果在这个指定的等待时间里面能够拿到mdl写锁最好，拿不到也不要阻塞后面的业务语句，先放弃。之后开发人员或者dba再通过重试命令重复这个过程。

mariadb已经合并了alisql的这个功能，所以这两个开源分支目前都支持ddl nowait/wait n这个语法。

alter table tbl_name nowait add column ...
alter table tbl_name wait n add column ...

行锁

mysql的行锁是在引擎层由各个引擎自己实现的。但并不是所有的引擎都支持行锁，比如myisam引擎就不支持行锁。

顾名思义，行锁就是针对数据表中行记录的锁。这很好理解，比如事务a更新了一行，而这时候事务b也要更新同一行，则必须等事务a的操作完成后才能进行更新。

两阶段锁

在innodb事务中，行锁是在需要的时候才加上的，但并不是不需要了就立刻释放，而是要等到事务结束时才释放。这个就是两阶段锁协议。

如果你的事务中需要锁多个行，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放。我给你举个例子。

假设你负责实现一个电影票在线交易业务，顾客a要在影院b购买电影票。我们简化一点，这个业务需要涉及到以下操作：
1. 从顾客a账户余额中扣除电影票价；
2. 给影院b的账户余额增加这张电影票价；
3. 记录一条交易日志。
也就是说，要完成这个交易，我们需要update两条记录，并insert一条记录。当然，为了保证交易的原子性，我们要把这三个操作放在一个事务中。那么，你会怎样安排这三个语句在事务中的顺序呢？
试想如果同时有另外一个顾客c要在影院b买票，那么这两个事务冲突的部分就是语句2了。因为它们要更新同一个影院账户的余额，需要修改同一行数据。

根据两阶段锁协议，不论你怎样安排语句顺序，所有的操作需要的行锁都是在事务提交的时候才释放的。所以，如果你把语句2安排在最后，比如按照3、1、2这样的顺序，那么影院账户余额这一行的锁时间就最少。这就最大程度地减少了事务之间的锁等待，提升了并发度。

死锁和死锁检测

当并发系统中不同线程出现循环资源依赖，涉及的线程都在等待别的线程释放资源时，就会导致这几个线程都进入无限等待的状态，称为死锁。

当出现死锁以后，有两种策略：

一种策略是，直接进入等待，直到超时。这个超时时间可以通过参数innodb_lock_wait_timeout来设置。
另一种策略是，发起死锁检测，发现死锁后，主动回滚死锁链条中的某一个事务，让其他事务得以继续执行。将参数innodb_deadlock_detect设置为on，表示开启这个逻辑。

在innodb中，innodb_lock_wait_timeout的默认值是50s，意味着如果采用第一个策略，当出现死锁以后，第一个被锁住的线程要过50s才会超时退出，然后其他线程才有可能继续执行。对于在线服务来说，这个等待时间往往是无法接受的。

主动死锁检测，而且innodb_deadlock_detect的默认值本身就是on。主动死锁检测在发生死锁的时候，是能够快速发现并进行处理的，但是它也是有额外负担的。

你可以想象一下这个过程：每当一个事务被锁的时候，就要看看它所依赖的线程有没有被别人锁住，如此循环，最后判断是否出现了循环等待，也就是死锁。

那如果是我们上面说到的所有事务都要更新同一行的场景呢？

每个新来的被堵住的线程，都要判断会不会由于自己的加入导致了死锁，这是一个时间复杂度是o(n)的操作。假设有1000个并发线程要同时更新同一行，那么死锁检测操作就是100万这个量级的。虽然最终检测的结果是没有死锁，但是这期间要消耗大量的cpu资源。因此，你就会看到cpu利用率很高，但是每秒却执行不了几个事务。

热点数据更新性能问题

问题的根本在于，死锁检测需要耗费大量的cpu资源

**如果你能确保这个业务一定不会出现死锁，可以临时把死锁检测关掉。**但是这种操作本身带有一定的风险，因为业务设计的时候一般不会把死锁当做一个严重错误，毕竟出现死锁了，就回滚，然后通过业务重试一般就没问题了，这是业务无损的。而关掉死锁检测意味着可能会出现大量的超时，这是业务有损的。
控制并发度,基本思路就是，对于相同行的更新，在进入引擎之前排队。这样在innodb内部就不会有大量的死锁检测工作了。
设计层优化。还是以影院账户为例，可以考虑放在多条记录上，比如10个记录，影院的账户总额等于这10个记录的值的总和。这样每次要给影院账户加金额的时候，随机选其中一条记录来加。这样每次冲突概率变成原来的1/10，可以减少锁等待个数，也就减少了死锁检测的cpu消耗。

本文将持续更新… 欢迎收藏

极客时间：林晓斌老师的mysql45讲学习笔记。