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
posted @ 2020-04-01 18:16  码猿手  阅读(...)  评论(...编辑  收藏
Live2D