MySQL笔记（9）-- 各种锁及实现

一、背景

　　MySQL有两种类型的锁：lock(锁)和latch(闩锁)：

类型	lock	latch
对象	事务	线程
保护	数据库内容	内存数据结构
持续时间	整个事务	临界资源
模式	行锁、表锁、意向锁	读写锁、互斥量
死锁	通过等待图和超时机制进行死锁检测和处理（deadlock detection through waits-for graph, timeout machanism）	无死锁检测和处理机制，仅通过应用程序加锁的顺序保证无死锁的情况发生
存在于	锁定管理器的哈希表（Lock Manager’s Hash Table）	每个数据结构的对象中

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

　　根据加锁的范围，MySQL里面的锁大致可以分为全局锁、表级锁和行锁三类，还会额外讨论MySQL其他的锁，比如排他锁、共享锁、乐观锁、悲观锁、间隙锁、死锁和解决死锁的机制等。

二、MySQL的锁类型

1.全局锁（global lock）

　　顾名思义，全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flush table with read lock(FTWRL)。当你需要让整个库处于只读状态的时候，可以使用这个命令，之后其他线程的以下语句会被阻塞：数据更新语句（数据的增删改）、数据定义语句（包括建表、修改表结构等）和更新类事务的提交语句。

　　全局锁的典型使用场景：做全库逻辑备份。也就是把整库每个表都select出来存成文本。

　　以前有一种做法，是通过FTWRL确保不会有其他线程对数据库做更新，然后对整个库做备份。注意，在备份过程中整个库完成处于只读状态。

　　但是让整库都只读，听上去就很危险：

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

　　看来加全局锁不太好。但是细想一下，备份为什么要加锁呢？我们来看一下不加锁会有什么问题。

　　假设你现在要维护一个培训网站的购买系统，关注的是用户账户余额表和用户课程表。

　　现在发起一个逻辑备份。假设备份期间，有一个用户，他购买了一门课程，业务逻辑里就要扣除他的余额，然后往已购课程里面加上一门课。

　　如果时间顺序上是先备份账号余额表(u_account)，然后用户购买，然后备份用户课程表(u_course)，会怎样呢？

　　可以看到，这个备份结果是，用户A的数据状态是“账号余额没扣，但是用户课程表里面已经多了一门课”，如果后面用这个来备份来恢复数据的话，用户A就发现，自己赚了。

　　作为用户可别觉得这样很好，你可以试想一下：如果备份表的顺序反过来，先备份用户课程表再备份账号余额表，又可能出现什么结果呢？

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

　　说到视图，在前面讲事务和实现的时候，其实是有一个方法能够拿到一致性视图的，就是在可重复读隔离级别下开启一个事务。

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

　　你一定在疑惑，有了这个功能，为什么还需要FTWRL呢？一致性读是好，但前提是引擎要支持这个隔离级别。比如，对于MyISAM这种不支持事务的引擎，如果备份过程中有更新，总是只能取到最新的数据，那么就破坏了备份的一致性。这时，我们就需要使用FTWRL命令。

　　所以，single-transaction方法只适用于所有的表使用事务引擎的库。如果有的表使用了不支持事务的引擎，那么备份就只能通过FTWRL方法。

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

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

　　业务的更新不只是增删改数据（DML），还有可能是加字段等修改表结构的操作（DDL）。不论是哪种方法，一个库被全局锁上以后，你要对里面任何一个表做字段操作，都是会被锁住的。

　　但是，即使没有被全局锁住，加字段也不是就能一帆风顺的，因为你还会碰到下面的表级锁。

2.表级锁（table lock）

　　MySQL里面的表级别的锁有两种：一种是表锁，一种是元数据锁（meta data lock[MDL]， 作用是防止DDL和DML并发的冲突）。

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

　　举个例子，如果在某个线程A中执行lock tables t1 read,t2 write;这个语句，则其他线程写t1、读写t2的语句都会被阻塞。同时，线程A在执行unlock tables之前，也只能执行读t1、读写t2的操作。连写t1都不允许，自然也不能访问其他表。

　　在还没有出现更细粒度的锁的时候，表锁是最常用的处理并发的方式。而对于InnoDB这种支持行锁的引擎，一般不使用lock tables命令来控制并发，毕竟锁住整个表的影响面还是太大。

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

　　因此，在MySQL5.5版本中引入了MDL，当对一个表做增删查改操作时，加MDL读锁；当要对表做结构变更操作时，加MDL写锁。

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

　　虽然MDL锁是系统默认会加的，但却是你不能忽略的一个机制。比如下面这个例子，给一个小表加个字段，导致整个库挂了。

　　给一个表加字段、或修改字段、或加索引，需要扫描全表的数据。在对大表操作的时候，你肯定会特别小心。而实际上，即使是小表，操作不慎也会出问题。我们来看一下下面的操作序列，假设t是一个小表。

　　我们可以看到sessionA先启动，这时候会对表t加一个MDL读锁。由于sessionB需要的也是MDL读锁，因此可以正常执行；之后sessionC会被blocked，是因为sessionA的MDL读锁还没有释放，而sessionC需要MDL写锁，因此只能被阻塞。

　　如果只有sessionC自己被阻塞还没什么关系，但是之后所有要在表t上新申请MDL读锁的请求也会被sessionC阻塞。前面说了，所有对表的增删查改操作都需要先申请MDL读锁，就都被锁住，等于这个表现在完全不可读写了。

　　如果某个表上的查询语句频繁，而且客户端有重试机制，也就是说超时后会再起一个新session再请求的话，这个库的线程很快就会爆满。

　　你现在理解了，事务中的MDL锁，在语句执行开始时申请，但是语句结束后并不会马上释放，而会等到整个事务提交后再释放。

　　基于上面的分析，那么如何安全地给小表加字段呢？

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

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

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

　　MySQL5.6支持online ddl，也就是对表操作增加字段等功能不会进行阻塞读写，Online DDL的过程是：

• Write locks with MDL（拿MDL写锁）
• Degraded to MDL Read Lock（降级成MDL读锁）
• Really do DDL（真正做DDL）
• Upgrade to MDL Write Lock（升级成MDL写锁）
• Release MDL locks（释放MDL锁）

　　1, 2, 4, 5 have very short execution time if there is no lock conflict. Step 3 takes up most of the DDL time, during which the table can read and write data normally.

　　1、2、4、5步骤如果没用锁冲突和执行时间非常短，第三步占用了DDL大部分时间，这个期间这个表是可以正常读写数据的。上面的例子是在第一步就堵住了，所以导致阻塞。

3.行锁（row lock）

　　MySQL的行锁是在引擎层由各个引擎自己实现的。但并不是所有的引擎都支持行锁，比如MyISAM引擎就不支持行锁。不支持行锁意味着并发控制只能使用表锁，对于这种引擎的表，同一张表任何时刻只能有一个更新在执行，这就会影响到业务并发度。InnoDB是支持行锁的【InnoDB使用自动行级锁。即使在只插入或删除一行的事务中，也可能出现死锁。这是因为这些操作并不是真正的“原子”;它们自动对(可能是多个)插入或删除行的索引记录设置锁。】，这也是MyISAM被InnoDB替代的重要原因之一。

　　显示执行行锁的两种方式：

• FOR UPDATE【使用FOR UPDATE子句持有的任何锁都不允许其他事务读取(使用FOR UPDATE子句)、更新或删除行，直到事务被提交或回滚，释放锁为止。这基本上是一个排他/写锁。这基本上是一个排他/写锁。】
• LOCK IN SHARE MODE【使用lock IN SHARE MODE子句持有的任何锁将允许其他事务读取锁定的行，但在事务提交或回滚并释放锁之前，不允许其他事务在该行上写操作。这基本上是一个共享/读锁。】

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

　　当然，数据库中还有一些没那么一目了然的概念和设计，这些概念如果理解和使用不当，容易导致程序出现非预期行为，比如两阶段锁。

　　从两阶段锁说起

　　在下面的操作序列中，事务B的update语句执行时会是什么现象呢？假设字段id是表t的关键。

　　这个问题的结论取决于事务A在执行完两天update语句后，持有哪些锁，以及在什么时候释放。你可以验证一下：实际上事务B的update语句会被阻塞，直到事务A执行commit之后，事务B才能继续执行。

　　知道了这个答案，你一定知道了事务A持有的两个记录的行锁，都是在commit的时候才释放的。

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

　　知道了这个设定，对我们使用事务有什么帮助呢？那就是，如果你的事务中需要锁多个行，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放。

　　假设你负责实现一个电影票在线交易业务，顾客A要到影院B购买电影票。我们简化一点，这个业务需要涉及到一下操作：

1. 从顾客A账号余额中扣除电影票价；
2. 给影院B的账号余额增加这张电影票价；
3. 记录一条交易日志；

　　也就是说，要完成这个交易，我们需要update两天记录，并insert一条记录。当然，为了保证交易的原子性，我们要把这三个操作放在一个事务中。那么，你会怎样安排这三个语句在事务中的顺序呢？

　　试想如果同时有另外一个顾客C要在影院B买票，那么这两个事务冲突的部分就是语句2了，因为它们要更新同一个影院账号的余额，需要修改同一行数据。

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

　　好了，由于你正确的设计，影院余额这一行的行锁在一个事务中不会停留很长时间。但是，这并没有完全解决你的困扰。

　　如果这个影院做活动，可以低价预售一年内所有的电影票，而且这个活动只做一天。于是在活动时间开始的时候，你的MySQL就挂了。你登上服务器一看，CPU消耗接近100%，但整个数据库每秒就执行不到100个事务。这是什么原因呢？

　　这里就是下面说的死锁了。

4.死锁（deadlock）

　　当并发系统中不同线程出现循环资源依赖，涉及的线程都在等待别的线程释放资源时，就会导致这几个线程都处于无限等待的状态，称为死锁。这里用数据库中的行锁来举个例子。

　　这时候，事务A在等待事务B释放id=2的行锁，而事务B在等待事务A释放id=1的行锁。事务A和事务B在互相等待对方的资源释放，就是进入了死锁状态。当出现死锁以后，有两种策略：

• 一种是直接进入等待，直到超时。当使用了Lock Tables语句或除了InnoDB其他引擎设置的表锁，就要使用超时时间设置来解决死锁。这个超时时间可以通过参数innodb_lock_wait_timeout来设置；
• 另一种是，发起死锁检测，发现死锁后，主动回滚死锁链条中的某一个事务，让其他事务得以继续执行，即InnoDB会自动检测事务死锁并回滚一个或多个事务以打破死锁。InnoDB尝试选择要回滚的小事务，其中事务的大小由插入、更新或删除的行数决定。将参数Innodb_deadlock_detect设置为0，表示开启这个逻辑。

　　对于死锁检测，官方文档显示“If the LATEST DETECTED DEADLOCK section of InnoDB Monitor output includes a message stating, ‘TOO DEEP OR LONG SEARCH IN THE LOCK TABLE WAITS-FOR GRAPH, WE WILL ROLL BACK FOLLOWING TRANSACTION,’ this indicates that the number of transactions on the wait-for list has reached a limit of 200. A wait-for list that exceeds 200 transactions is treated as a deadlock and the transaction attempting to check the wait-for list is rolled back. The same error may also occur if the locking thread must look at more than 1,000,000 locks owned by transactions on the wait-for list.”

　　InnoDB使用等待图来发现死锁，而当wait-for列表中的事务量达到LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK设置的量（默认200）时也会认为发生了“死锁”。此时可在SHOW ENGINE INNODB STATUS的输出中看到“TOO DEEP OR LONG SEARCH IN THE LOCK TABLE WAITS-FOR GRAPH, WE WILL ROLL BACK FOLLOWING TRANSACTION”这么一行内容。还有，当wait-for列表中的事务拥有的锁超过LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK(默认1000000)时也会认为发生了“死锁”。

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

　　但是，我们又不可能直接把这个时间设置为一个很小的值，比如1s。这样当出现死锁时确实很快就可以解开，但如果不是死锁，而是简单的锁等待呢？所以，超时时间设置太短的话，会出现很多误伤。

　　所以，正常情况下还是采用第二种策略：主动死锁检测，而且Innodb_deadlock_detect的默认值本身就是on。主动死锁检测在发生死锁的时候，是能够快速发现并进行处理的，但是它也是有额外负担的。

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

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

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

　　根据上面的分析，我们来讨论一下，怎么解决由这些热点行更新导致的性能问题呢？【MySQL8.0.1使用了“SKIP LOCKED"和“NOWAIT"来处理热点行】问题的症结在于，死锁检测要耗费大量的CPU资源。

　　一种头痛医头的方法，就是如果你能确保这个业务一定不会出现死锁，可以临时把死锁检测关掉。但是这种操作本身带有一定的风险，因为业务设计的时候一般不会把死锁当做一个严重错误，毕竟出现死锁了，就回滚，然后通过业务重试一般就没问题了，这是业务无损的。而关掉死锁检测意味着可能会出现大量的超时，这是业务有损的。

　　另一个思路是控制并发度。根据上面的分析，你会发现如果并发能够控制住，比如同一行同时最多只有10个线程在更新，那么死锁检测的成本就很低，就不会出现这个问题。一个直接的想法就是，在客户端做并发控制。但是，你会很快发现这个方法不太可行，因为客户端很多，比如有一个应用，有600个客户端，这样即使每个客户端控制到只有5个并发线程，汇总到数据库服务端以后，峰值并发数也可能要达到3000。

　　因此，这个并发控制要做在数据库服务端。如果有中间件，可以考虑在中间件实现；如果有能修改MySQL源码的人，可以做在MySQL里面。基本思路就是，对于相同行的更新，在进入引擎之前排队。这样在InnoDB内部就不会有大量的死锁检测工作了。

　　如果上面的方法你无法实现，你可以考虑通过将一行改成逻辑上的多行来减少锁冲突。还是以影院账号为例，可以考虑放在多条记录上，比如10个记录，影院账号总额等于这10个记录的值的总和。这样每次要给影院账号加金额的时候，随机选其中一条记录来加。这样每次冲突概率变成原来的1/10，可以减少锁等待个数，也就减少了死锁检测的CPU消耗。

　　这个方案看上去是无损的，但其实这类方案需要根据业务逻辑做详细设计。如果账号余额可能会减少，比如退票逻辑，那么这时候就需要考虑当一部分行记录变成0的时候，代码要有特殊处理。

　　如果死锁的情况太多，可以使用innodb_print_all_deadlocks来打印所有的死锁信息，所有的信息会保存到error log日志中。

　　如果使用了select..for update或者select ... lock in share mode这样的语句来锁定读取，那么可以尝试使用更低的隔离级别比如提交读(Read Committed)来减少发生死锁的概率。

5.排他锁（exclusive[X] lock）

　　排他锁也叫写锁，允许持有锁的事务更新或删除行。即当进行修改操作时会获得写锁，在一定的时间范围内，只能存在一个写锁。如果在资源上没有读/写锁，事务可以立即获得写锁。当写锁没有被释放时，其他的所有锁请求都只能等待。

　　值得注意的是，写锁的优先级高于读锁。当一个资源上没有锁时，或者所有的锁请求都在等待队列中，下面是锁的授予方式：

• 首先将锁授予写锁队列中等待的请求；
• 如果写锁队列中没有对资源的锁请求，那么将锁授予读锁队列中的第一个请求。

6.共享锁（shared[S] lock）

　　共享锁也叫读锁，允许持有锁的事务读取一行。即不能进行写操作来提供一致性读取。如果资源上没有写锁，事务可以立即获得读锁，多个事务可以在同时获得读锁，如果读锁没有释放，写锁不能被获取，写事务只能放入等待队列。

7.乐观锁（optimistic lock）　

　　关系数据库中对性能和并发性的需求意味着（关系数据库）的启动和调度操作都是快速的。一致性和完整性的需求意味着任何操作都可能失败：事务可能被回滚，一个DML操作可能违反约束，对锁的请求可能导致死锁，一个网络错误可能导致超时。乐观策略是一种假设大多数请求或尝试都会成功，因此为失败案例做的准备相对比较少。当这个假设成立时，数据库几乎不需要做任何工作。当请求确实失败时，就必须做更多的工作来清理和撤销更改。即乐观锁允许数据的冲突，但会在数据提交时进行检测。

　　许多内置的数据库机制都使用乐观策略。

　　InnoDB对锁和提交等操作使用乐观策略，例如，一个做数据更改的事务可以在提交之前写入数据文件，这使得提交本身非常快，但是如果事务回滚，则需要更多的工作来撤销更改。

　　乐观锁也叫行版本控制，它不会锁定任何事务；MySQL内部会管理不同的行版本号，所以当进行读操作即读取其中一个版本号的数据时，在同时有一个写操作对这个数据进行更新，它会对这个数据创建一个新的版本号，再下一次读取时，会读取最新版本号的数据，而对老版本号的数据进行标记为死亡元组（dead tuple）；

　　在上面的关系图中，Alice的写操作检测到了版本更新并发生了冲突，导致操作失败。【每次执行更新或删除操作时，version都会递增，更新和删除语句的WHERE子句也会使用它。我们需要在执行更新或删除之前发起SELECT查询并读取当前版本，否则，我们不知道将哪个版本值传递给WHERE子句或增加哪个版本值。】

• MVCC体系结构依赖于乐观锁定的概念；PostgreSQL和MySQL InnoDB等RDBMS完全基于MVCC；Microsoft SQL Server也具有快照隔离，这也是一种乐观锁。

• 不会对读写加锁；
• 使用乐观锁访问数据时，有70％的机会获得最后提交的数据版本，但它提供了快速访问权限，因为它从未在事务之间创建依赖关系。
• 通常，大多数Web和移动应用程序都适合最后提交的数据版本。

8.悲观锁（pessimistic lock）

　　InnoDB使用了悲观锁策略使产生死锁的机会最小化。悲观策略是一种为了安全而牺牲性能或并发性的方法。如果大部分请求或尝试可能失败，或者失败的请求的后果非常严重，则适合使用悲观策略。在应用级别你可以使用悲观策略来避免死锁，即在开始时获取事务所需的所有锁。

　　悲观锁是在进行编辑一条记录时维护一个独占锁，对于最终用户来说，在这个锁没有被释放前，它（记录）不能被其他人进行编辑。

　　在上面的关系图中，Alice和Bob都对记录id为1的数据获取了一个读锁，因为他们都获取了读锁，所以他们不能对记录进行写操作，只有等Alice释放了读锁，Bod才能进行写操作。

• 排他锁和共享锁都属于悲观锁；
• 隔离级别像Read Committed(RC提交读）、Repeatable Read(RR重复读）和Serializable(串行化)也是使用了悲观锁；
• 每当出现问题时，它都会锁定事务，并将事务放入阻塞队列。悲观锁使你可以访问活动的和提交的数据，没有机会访问脏数据；
• 像银行或金融系统这样大型的OLTP（On-Line Transaction Processing联机事务处理过程）系统因为对读写数据的准确性的要求，他们比较喜欢使用悲观锁；对于大系统来说，锁是一种额外的开销;

9.间隙锁（gap lock）

 　　顾名思义就是在索引记录之间的间隙的锁，或者是在第一个索引记录之前和最后一个索引记录之后的间隙的锁。比如下面的例子：

select c1 from t where c1 between 10 and 20 for update;

　　当执行这条语句时，MySQL会对t表中c1值从10到20之间的行数加上间隙锁，阻止其他事务对t.c1的列值在10到20之间进行插入，比如t.c1插入一条新的记录值为15，不管列中是否已经有15这样的值，插入是不成功的，因为在10到20之间的间隙都是锁定的。

　　比如你对t.c1中大于10的值都进行更新操作，那么你无法对t.c1的列中插入大于10的值，这也是间隙锁的体现。

10.记录锁（record lock）

　　一种索引记录上的锁。比如下面的语句：

select c1 from t where c1=10 for update;

　　当执行这条语句时，会阻止其他事务对t.c1为10的这一行数据进行增删改操作。

三、讨论

　　1.备份一般都会在备库上执行，你在用–single-transaction 方法做逻辑备份的过程中，如果主库上的一个小表做了一个 DDL，比如给一个表上加了一列。这时候，从备库上会看到什么现象呢？

 答案：假设这个DDL是针对表t1的，下面是备份过程中 几个关键的语句：

Q1:SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
Q2:START TRANSACTION  WITH CONSISTENT SNAPSHOT；
/* other tables */
Q3:SAVEPOINT sp;
/* 时刻 1 */
Q4:show create table `t1`;
/* 时刻 2 */
Q5:SELECT * FROM `t1`;
/* 时刻 3 */
Q6:ROLLBACK TO SAVEPOINT sp;
/* 时刻 4 */
/* other tables */

　　在备份开始的时候，为了确保RR(可重复读）隔离级别，再设置一次RR隔离级别（Q1）；

　　启动事务，这里用WITH CONSISTENT SNAPSHOT确保这个语句执行完就可以得到一个一致性视图（Q2）；

　　设置一个保存点，这个很重要（Q3）；

　　show create是为了拿到表结构（Q4），然后正式导数据（Q5），回滚到SAVEPOINT sp，在这里的作用是释放t1的MDL锁（Q6）。

　　DDL从主库传过来的时候按照效果不同，设置了4个时刻。题目设定为小表，假定到达后，如果开始执行，则很快能够执行完成。

1. 如果在Q4语句执行之前到达，现象：没有影响，备份拿到的是DDL后的表结构；
2. 如果在”时刻2“到达，则表结构被改过，Q5执行的时候，报Table definition has changed,please retry transaction，现象：mysqldump终止；
3. 如果在“时刻2”和“时刻3”之间到达，mysqldump占着t1的MDL读锁，binlog被阻塞，现象：主从延迟，直到Q6执行完成；
4. 从“时刻4”开始，mysqldump释放了MDL读锁，现象：没有影响，备份拿到的是DDL前的表结构。

　　2.如果你要删除一个表里面的前 10000 行数据，有以下三种方法可以做到：

•  第一种，直接执行 delete from T limit 10000;
• 第二种，在一个连接中循环执行 20 次 delete from T limit 500;
• 第三种，在 20 个连接中同时执行 delete from T limit 500。

答案：第二种方式，即：在一个连接中循环执行 20 次 delete from T limit 500。

　　   第一种方式（即：直接执行 delete from T limit 10000）里面，单个语句占用时间长，锁的时间也比较长；而且大事务还会导致主从延迟。

　　   第三种方式（即：在 20 个连接中同时执行 delete from T limit 500），会人为造成锁冲突。

参考：

• MySQL概念：https://oxnz.github.io/2014/02/27/mysql-primer-concepts/
• 全局锁、表级锁：https://developpaper.com/deep-understanding-of-mysql-global-lock-and-table-lock/
• MySQL8.0.1s使用“SKIP LOCKED"和“NOWAIT"处理热点行:
  • https://mysqlserverteam.com/mysql-8-0-1-using-skip-locked-and-nowait-to-handle-hot-rows/
  • https://www.percona.com/blog/2018/06/29/mysql8-hot-rows-with-nowait-skip-locked/
  • https://yq.aliyun.com/articles/159602
• 如何最小化和死锁：https://dev.mysql.com/doc/refman/5.7/en/innodb-deadlocks-handling.html
• 死锁检测和回滚：https://dev.mysql.com/doc/refman/5.7/en/innodb-deadlock-detection.html
• 避免死锁的终极策略：https://www.dbrnd.com/2016/04/database-design-the-ultimate-strategies-to-avoid-deadlock/
• 解释InnoDB显式锁定机制：https://blog.toadworld.com/2018/01/11/explaining-innodb-explicit-locking-mechanisms
• 乐观锁和悲观锁：
  • https://www.dbrnd.com/2016/04/database-theory-what-is-optimistic-locking-and-pessimistic-locking/
  • https://dev.mysql.com/doc/refman/5.7/en/glossary.html#glos_optimistic
  • https://dev.mysql.com/doc/refman/5.7/en/glossary.html#glos_pessimistic
  • https://enterprisecraftsmanship.com/posts/optimistic-locking-automatic-retry/
  • https://stackoverflow.com/questions/129329/optimistic-vs-pessimistic-locking
• 间隙锁：https://dev.mysql.com/doc/refman/5.7/en/glossary.html#glos_gap_lock
• 记录锁：https://dev.mysql.com/doc/refman/5.7/en/glossary.html#glos_record_lock