MySQL 进阶篇 Part 2

😉 本文共7710字，阅读时间约12min

目录

• MYSQL锁
  • 概述
  • 全局锁
  • 表级锁
    • 介绍
    • 表锁
    • 元数据锁
    • 意向锁
  • 行级锁
    • 介绍
    • 行锁
    • 间隙锁&临键锁
• InnoDB引擎架构
  • 逻辑存储
  • 内存结构和磁盘结构
    • 内存结构与Buffer Pool
    • 磁盘结构
    • Redo Log
  • 后台线程
• 事务原理
  • • 事务定义
    • ACID/事务如何实现？
    • undo log
    • 幻读问题的解决
• MVCC原理
  • 当前读与快照读
  • MVCC如何实现
    • 隐藏字段
    • undo log 版本链
    • readview
• 两段锁协议（2PL）
  • 保证事务串行化
• mysql的两阶段提交
  • binlog
  • 原因：主从同步问题
  • 在两阶段提交的情况下，是怎么实现崩溃恢复的呢？

MYSQL锁

概述

1. 锁是协调多个线程并发访问资源的机制
2. 锁冲突非常影响数据库并发访问性能，互斥的表现就是阻塞对方的操作
3. MySQL中的锁，按照锁的粒度分，分为以下三类：
   1. 全局锁：锁定整个数据库实例。
   2. 表级锁：每次操作锁住整张表。
   3. 行级锁：每次操作锁住对应的行数据。

全局锁

1. 全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的DML的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。

2. 其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性。

   不加全局锁，逐个备份表，期间可能发生表更新，比如订单表和库存表就会出现不一致。有最新操作的订单信息,但是库存数没减。加了全局锁，就可以保证数据的一致性。

3. 语法

   -- 加全局锁
   flush tables with read lock;
   -- 释放锁
   unlock tables;
   

4. 数据库中加全局锁，是一个比较重的操作，存在以下问题：

   1. 如果在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆。
   2. 如果在从库上备份，那么备份期间从库不能执行主库同步过来的二进制日志（binlog），导致主从延迟。

表级锁

介绍

表级锁，每次操作锁住整张表。锁定粒度大，发生锁冲突的概率最高，并发度最低。应用在MyISAM、InnoDB、BDB等存储引擎中。

对于表级锁，主要分为以下三类：

• 表锁
• 元数据锁（meta data lock，MDL）
• 意向锁

每种又可分：

• 共享锁（读锁）
• 排他锁（写锁）

表锁

1. 对于表锁，分为两类：

   1. 表共享读锁（read lock）
   2. 表独占写锁（write lock）

2. 语法：

   -- 加锁
   lock tables xxx read/write
   -- 解锁
   unlock tables / 客户端断开连接
   

3. 特点：

   1. 多个线程间，读读共享，读写阻塞，写写阻塞
   2. 单个线程，获取独占锁，可读可写

元数据锁

1. meta data lock , 元数据锁。MDL锁主要作用是维护表元数据的数据一致性，在表上有活动事务的时候，不可以对元数据进行写入操作。为了避免DML与DDL冲突，保证读写的正确性。MDL加锁过程是系统自动控制，无需显式使用，在访问一张表的时候会自动加上。

   这里的元数据，大家可以简单理解为就是一张表的表结构。 也就是说，某一张表涉及到未提交的事务时，是不能够修改这张表的表结构的。

2. 当对一张表进行增删改查的时候，加MDL读锁(共享)；当对表结构进行变更操作的时候，加MDL写锁(排他)。

   当执行SELECT、INSERT、UPDATE、DELETE等语句时，添加的是元数据共享锁（SHARED_READ /
   SHARED_WRITE），之间是兼容的。

   当执行SELECT语句时，添加的是元数据共享锁（SHARED_READ），会阻塞元数据排他锁（EXCLUSIVE），之间是互斥的。

3. 依旧符合读写锁特点

意向锁

1. 作用

   1. 为了避免DML在执行时加的行锁与表锁的冲突，在InnoDB中引入了意向锁，使得表锁不用逐行判断是否加锁，使用意向锁来减少表锁的检查。
   2. 假如没有意向锁，客户端一对表加了行锁后，客户端二如何给表加表锁呢?
      1. 首先客户端一，开启一个事务，然后执行DML操作，在执行DML语句时，会对涉及到的行加行锁。
      2. 当客户端二，想对这张表加表锁时，会检查当前表是否有对应的行锁，如果没有，则添加表锁，此时就会从第一行数据，检查到最后一行数据，效率较低。
   3. 有了意向锁之后 :
      1. 客户端一，在执行DML操作时，会对涉及的行加行锁，同时也会对该表加上意向锁。
      2. 而其他客户端，在对这张表加表锁的时候，会根据该表上所加的意向锁来判定是否可以成功加表锁，而不用逐行判断行锁情况了。

2. 分类

   1. 意向共享锁(IS): 由语句select ... lock in share mode添加 。与表锁共享锁(read)兼容，与表锁排他锁(write)互斥。

   2. 意向排他锁(IX): 由insert、update、delete、select...for update添加 。与表锁共享锁(read)及排他锁(write)都互斥，意向锁之间不会互斥。

      一旦事务提交了，意向共享锁、意向排他锁，都会自动释放。

行级锁

介绍

1. 行级锁，每次操作锁住对应的行数据。锁定粒度最小，发生锁冲突的概率最低，并发度最高。应用在InnoDB存储引擎中。

2. InnoDB的数据是基于索引组织的，行锁是通过对索引上的索引项加锁来实现的，而不是对记录加的锁。对于行级锁，主要分为以下三类：

   1. 行锁（Record Lock）：锁定单个行记录的锁，防止其他事务对此行进行update和delete。在RC、RR隔离级别下都支持。

      

   2. 间隙锁（Gap Lock）：锁定索引记录间隙（不含该记录），确保索引记录间隙不变，防止其他事务在这个间隙进行insert，产生幻读。在RR隔离级别下都支持。（解决的是当前读下的幻读）

      幻读: 一个事务在前后两次查询同一个范围的时候、后一次查询看到了前一次查询未看到的行.。幻读是指另一个事务插入并提交的数据被当前事务读取到。

      在可重复读隔离级别下、普通查询是快照读、不会看到别的事务插入数据, 所以、只会在当前读下才会出现.

      

   3. 临键锁（Next-Key Lock）：行锁和间隙锁组合，同时锁住数据，并锁住数据前面的间隙Gap。在RR隔离级别下支持。

      

行锁

1. 介绍

   InnoDB实现了以下两种类型的行锁：

   1. 共享锁（S）：允许一个事务去读一行，阻止其他事务获得相同数据集的排它锁。
   2. 排他锁（X）：允许获取排他锁的事务更新数据，阻止其他事务获得相同数据集的共享锁和排他锁。

2. 常见的SQL语句，在执行时，所加的行锁如下：

   SQL	行锁类型	说明
   INSERT,UPDATE,DELETE ...	排他锁	自动加锁
   SELECT（正常）	不加任何锁	因为属于快照读，不是当前读
   SELECT ... LOCK IN SHARE MODE	共享锁	需要手动在SELECT之后加LOCK IN SHARE MODE
   SELECT ... FOR UPDATE	排他锁	需要手动在SELECT之后加FOR UPDATE

3. 演示

   默认情况下，InnoDB在 REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读。

• 针对唯一索引进行检索时，对已存在的记录进行等值匹配时，将会自动优化为行锁。
• InnoDB的行锁是针对于索引加的锁，不通过索引条件检索数据，那么InnoDB将对表中的所有记录加锁，此时 就会升级为表锁。无索引行锁升级为表锁。

-- 在客户端一中，开启事务，并执行update语句，更新name为Lily的数据，也就是id为19的记录 。然后在客户端二中更新id为3的记录，却不能直接执行，会处于阻塞状态，为什么呢？
-- 原因就是因为此时，客户端一，根据name字段进行更新时，name字段是没有索引的，如果没有索引，此时行锁会升级为表锁(因为行锁是对索引项加的锁，而name没有索引)。
-- 接下来，我们再针对name字段建立索引，索引建立之后，再次做一个测试,此时客户端二就不会阻塞了。

间隙锁&临键锁

默认情况下，InnoDB在 REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读。

• 索引上的等值查询(唯一索引)，给存在的记录加锁时, 优化为行锁 。

• 索引上的等值查询(唯一索引)，给不存在的记录加锁时, 优化为间隙锁 。
• 索引上的范围查询(唯一索引)--会访问到不满足条件的第一个值为止。
• 索引上的等值查询(非唯一普通索引)，向右遍历时最后一个值不满足查询需求时，next-key lock 退化为间隙锁。

• 如果走了索引：
  • 在该索引上，所有匹配的 索引记录 上Next-key Lock，对应的聚集索引 上Record Lock;
  • 对于 < 和 <=，会在该索引上向右扫描， 直到找到 [不匹配的索引记录] 上Next-key Lock，对应的聚集索引 上Record Lock;
  • 对于 > 和 >=，会对supremum (上界限伪值) 上Next-key Lock：锁的是 该索引 最大值 后面的 间隙;
• 如果没走索引，那么就会把所有 聚集索引记录 和 间隙 都锁上，就是所谓的锁表，或叫行锁升表锁.

tip 注意:

间隙锁唯一目的是防止其他事务插入间隙。间隙锁可以共存，一个事务采用的间隙锁不会阻止另一个事务在同一间隙上采用间隙锁。

A. 索引上的等值查询(唯一索引)，给不存在的记录加锁时, 优化为间隙锁 。

B. 索引上等值查询(非唯一普通索引)，向右遍历到最后一个值不满足查询需求时，next-key lock 退化为间隙锁。

介绍分析一下：

我们知道InnoDB的B+树索引，叶子节点是有序的双向链表。 假如，我们要根据这个二级索引查询值为18的数据，并加上共享锁，我们是只锁定18这一行就可以了吗？ 并不是，因为是非唯一索引，这个结构中可能有多个18的存在，所以，在加锁时会继续往后找，找到一个不满足条件的值（当前案例中也就是29）。此时会对18加临键锁，并对29之前的间隙加锁。

C. 索引上的范围查询(唯一索引)--会访问到不满足条件的第一个值为止。

查询的条件为id>=19，并添加共享锁。 此时我们可以根据数据库表中现有的数据，将数据分为三个部分：

[19]

(19,25]

(25,+∞]

所以数据库数据在加锁是，就是将19加了行锁，25的临键锁（包含25及25之前的间隙），正无穷的临键锁(正无穷及之前的间隙)。

InnoDB引擎架构

逻辑存储

😆就是一张表的逻辑存储结构

1. 表空间

   innoDB引擎的每张表都会对应这样一个表空间文件，存储该表的表结构、数据和索引。

2. 段

   分为数据段、索引段、回滚段。InnoDB是索引组织表，数据段就是B+树的叶子节点， 索引段即为B+树的非叶子节点。段用来管理多个Extent（区）。

3. 区

   区，表空间的单元结构，每个区的大小为1M。 默认情况下， InnoDB存储引擎页大小为16K， 即一个区中一共有64个连续的页。

4. 页

   页，是InnoDB 存储引擎磁盘管理的最小单元，每个页的大小默认为 16KB。为了保证页的连续性，InnoDB 存储引擎每次从磁盘申请 4-5 个区。

5. 行

   行，InnoDB 存储引擎数据是按行进行存放的。在行中，默认有两个隐藏字段：事务id和回滚指针

   1. Trx_id：每次对某条记录进行改动时，都会把对应的事务id赋值给trx_id隐藏列。
   2. Roll_pointer：每次对某条引记录进行改动时，都会把旧的版本写入到undo日志中，然后这个隐藏列就相当于一个指针，可以通过它来找到该记录修改前的信息。

内存结构和磁盘结构

内存结构与Buffer Pool

主要分为这么四大块儿： Buffer Pool、Change Buffer、Adaptive Hash Index、Log Buffer。

1. Buffer Pool

   1. 出现原因：InnoDB存储基于磁盘文件存储，访问物理硬盘和在内存中进行访问，速度相差很大，为了尽可能弥补这两者之间的I/O效率的差值，就需要把经常使用的数据加载到缓冲池中，避免每次访问都进行磁盘I/O。

   2. 作用：可以缓存磁盘上经常操作的真实数据，在执行增删改查操作时，先操作缓冲池中的数据（若缓冲池没有数据，则从磁盘加载并缓存），然后再以一定频率刷新到磁盘，从而减少磁盘IO，加快处理速度。

      1. 在InnoDB的缓冲池中不仅缓存了索引页和数据页，还包含了undo页、插入缓存、自适应哈希索引以及InnoDB的锁信息等等。

   3. 缓冲池以Page页为单位，底层采用链表数据结构管理Page。根据状态，将Page分为三种类型：

      • free page：空闲page，未被使用。
      • clean page：被使用page，数据没有被修改过。
      • dirty page：脏页，被使用page，数据被修改过，也中数据与磁盘的数据产生了不一致。

2. Change Buffer

   1. 出现原因：在缓冲池合并处理，防止索引树的二级索引页被频繁影响，以减少磁盘I/O

      与聚集索引不同，二级索引通常是非唯一的，并且以相对随机的顺序插入二级索引。同样，删除和更新可能会影响索引树中不相邻的二级索引页，如果每一次都操作磁盘，会造成大量的磁盘IO。有了ChangeBuffer之后，我们可以在缓冲池中进行合并处理，减少磁盘IO。

   2. 更改缓冲区（针对于非唯一二级索引页），在执行DML语句时，如果这些数据Page没有在Buffer Pool中，不会直接操作磁盘，而会将数据变更存在更改缓冲区 Change Buffer中，在未来数据被读取时，再将数据合并恢复到Buffer Pool中，再将合并后的数据刷新到磁盘中。

3. Adaptive Hash Index

   1. 自适应hash索引，用于优化对Buffer Pool数据的查询。MySQL的innoDB引擎中虽然没有直接支持hash索引，但是给我们提供了一个功能就是这个自适应hash索引。
   2. hash索引在进行等值匹配时，一般性能是要高于B+树的，因为hash索引一般只需要一次IO即可，而B+树，可能需要几次匹配，所以hash索引的效率要高，但是hash索引又不适合做范围查询、模糊匹配等。
   3. InnoDB存储引擎会监控对表上各索引页的查询，如果观察到在特定的条件下hash索引可以提升速度，则建立hash索引，称之为自适应hash索引。

4. Log Buffer

   1. 日志缓冲区，用来保存要写入到磁盘中的log日志数据（redo log 、undo log），默认大小为 16MB，日志缓冲区的日志会定期刷新到磁盘中。如果需要更新、插入或删除许多行的事务，增加日志缓冲区的大小可以节省磁盘 I/O。
   2. 日志刷新到磁盘时机, 默认是日志在每次事务提交时写入并刷新到磁盘

磁盘结构

1. 各种表空间，如系统表空间，通用表空间，每张表的表空间，临时表的表空间
2. undo表空间：用于存储 undo log日志
3. redo log

Redo Log

1. 用来实现事务的持久性，系统崩溃后可以根据redo log进行恢复
2. 出现原因：
   1. innodb是以页为单位来管理存储空间的，任何的增删改差操作最终都会操作完整的一个页，会将整个页加载到buffer pool中，然后对需要修改的记录进行修改，修改完毕不会立即刷新到磁盘，因为此时的刷新是一个随机io，而且仅仅修改了一条记录，刷新一个完整的数据页的话过于浪费了。但是如果不立即刷新的话，数据此时还在内存中，如果此时发生系统崩溃最终数据会丢失的，因此权衡利弊，引入了redo log。
   2. 也就是说，修改完后，不立即刷新，而是记录一条日志，日志内容就是记录哪个页面，多少偏移量，什么数据发生了什么变更。这样即使系统崩溃，再恢复后，也可以根据redo日志进行数据恢复。另外，redo log是循环写入固定的文件，是顺序写入磁盘的。
      1. 为啥要redo log，数据直接刷盘不行吗？看原因1。本质就是改一次刷一个完整的页太浪费了，所以做了一个日志缓存redo log buffer，为了防止这个缓存带来的崩溃丢失问题，引入持久化的redo log。
3. 该日志文件由两部分组成：
   1. redo log buffer ，在内存
   2. redo log , 在磁盘
4. redo log的刷盘时机：建议事务commit的时候刷盘，来保证事务的持久性

5. 一条更新语句的执行步骤 update table set id = 10 where id = 1;
   1. 连接数据库 …
   2. 判断id=1的这条记录在不在buffer pool中，在的话之间更新，否则从磁盘中加载到buffer pool中，然后进行更新
   3. 将这个更新操作记录到redo log中，记录的是一个物理日志。此时redo log是一个prepare状态
   4. 记录该操作的binlog，并且将binlog刷盘
   5. 提交事务，对redo log进行提交。

WAL的套路

先写日志，后写数据

WAL的全称是 Write-ahead logging, 预写式日志，是一种常见的用于持久化数据的方式, 通常性能都很不错, 利用了磁盘连续写的性能高于随机读写的这一个特性.

一般来说, WAL都是用于这样一种场景, 记录操作日志, 数据库收到合法请求之后, 首先在WAL里写入一条记录, 然后再开始进行内存 操作以及需要更长时间的操作, 假如此时应用崩溃, 那么应用可以读取WAL来进行重建/修复, 也就是说, 只要提交到WAL里并且落盘的数据, 就可以认为是一定被持久化了的.

我们操作数据一般都是随机读写磁盘的，而不是顺序读写磁盘。 而redo log在往磁盘文件中写入数据，由于是日志文件，所以都是顺序写的。顺序写的效率，要远大于随机写。

内存的读写速度比随机读写磁盘高出几个数量级。

磁盘顺序读写效率堪比内存

面试题：随机写性能很低，有没有其他方法？
借鉴MySQL原理，把修改记录写入日志（顺序写）避免丢失，然后在内存修改value，定时或者定量之后再刷磁盘

后台线程

分为4类，分别是：Master Thread 、IO Thread、Purge Thread、Page Cleaner Thread。

1. Master Thread

   核心后台线程，负责调度其他线程，刷新脏页, 保持数据的一致性

2. IO Thread

   大量使用了AIO来处理IO请求, 这样可以极大地提高数据库的性能，而IOThread主要负责这些IO请求的回调。比如Read thread，Write thread，Log thread（将日志缓冲区刷新到磁盘）。

3. Purge Thread

   主要用于回收事务已经提交了的undo log，在事务提交之后，undo log可能不用了，就用它来回收。

4. Page Cleaner Thread

   协助 Master Thread 刷新脏页到磁盘，它可以减轻 Master Thread 的工作压力，减少阻塞。

事务原理

事务定义

事务要符合ACID特性

1. 保证一个事务内内容同时成功、同时失败。

2. 事务完成时，必须使所有的数据都保持一致状态。

3. 隔离机制，保证并发下事务的隔离性。

4. 事务一旦提交或回滚，它对数据库中的数据的改变就是永久的

ACID/事务如何实现？

ACD是由redo log和undo log实现的，I隔离性是由锁和MVCC实现的

undo log

回滚日志，用于记录数据被修改前的信息

1. 作用：

   1. 提供回滚(保证事务的原子性)
   2. MVCC(多版本并发控制)

2. 内容

   undo log和redo log记录物理日志不一样，它是逻辑日志。可以认为当delete一条记录时，undolog中会记录一条对应的insert记录，反之亦然，当update一条记录时，它记录一条对应相反的update记录。当执行rollback时，就可以从undo log中的逻辑记录读取相应的内容并进行回滚。

3. 存储：采用段的方式进行管理和记录，存放在前面介绍的表空间的回滚段中

幻读问题的解决

1. 幻读指的是一个事务在前后两次查询同一个范围的时候，后一次查询看到了前一次查询没有看到的行。重在插入的新数据。而不可重复读针对的是更新和删除。
2. 在可重复读隔离级别下，普通的查询是快照读，是不会看到 别的事务插入的数据的。因此，幻读在“当前读”下才会出现。
3. 解决幻读：MVCC加上间隙锁的方式
   （1）在快照读读情况下，mysql通过mvcc来避免幻读。
   （2）在当前读读情况下，mysql通过next-key来避免幻读。锁住某个条件下的数据不能更改。

事实上，分清问题的解决，第一步是分清当前是当前读还是快照读。

MVCC原理

多版本并发控制。指维护一个数据的多个版本，使得读写操作没有冲突，快照读为MySQL实现MVCC提供了一个非阻塞读功能。

当前读与快照读

1. 当前读
   1. 读取的是记录的最新版本，读取时还要保证其他并发事务不能修改当前记录，会对读取的记录进行加锁。
   2. 对于我们日常的操作，如：select ... lock in share mode(共享锁)，select ...for update、update、insert、delete(排他锁)都是一种当前读。
2. 快照读
   1. 简单的select（不加锁）就是快照读，快照读，读取的是记录数据的可见版本，有可能是历史数据，不加锁，是非阻塞读。
   2. Read Committed：每次select，都生成一个快照读。
   3. Repeatable Read：开启事务后第一个select语句才是快照读的地方。
   4. Serializable：快照读会退化为当前读。

MVCC如何实现

行的隐藏字段、undo log、readview

隐藏字段

隐藏字段	含义
DB_TRX_ID	最近修改事务ID，记录插入这条记录或最后一次修改该记录的事务ID，自增。
DB_ROLL_PTR	回滚指针，指向这条记录的上一个版本，配合undo log，指向上一个版本。
DB_ROW_ID	隐藏主键，如果表结构没有指定主键，将会生成该隐藏字段。

而上述的前两个字段是肯定会添加的， 是否添加最后一个字段DB_ROW_ID，得看当前表有没有主键，如果有主键，则不会添加该隐藏字段。

undo log 版本链

1. 当insert的时候，产生的undo log日志只在回滚时需要，在事务提交后，可被立即删除。而update、delete的时候，产生的undo log日志不仅在回滚时需要，在快照读时也需要，不会立即被删除。

我们发现，不同事务或相同事务对同一条记录进行修改，会导致该记录的undolog生成一条记录版本链表，链表的头部是最新的旧记录，链表尾部是最早的旧记录。

readview

ReadView（读视图）是 快照读 SQL执行时MVCC提取数据的依据，记录并维护系统当前活跃的事务（未提交的）id。

ReadView中包含了四个核心字段：

字段	含义
m_ids	当前活跃的事务ID集合
min_trx_id	最小活跃事务ID
max_trx_id	预分配事务ID，当前最大事务ID+1（因为事务ID是自增的）
creator_trx_id	ReadView创建者的事务ID

而在readview中就规定了版本链数据的访问规则：

trx_id 代表当前undolog版本链对应事务ID。

条件	是否可以访问	说明
trx_id == creator_trx_id	可以访问该版本	成立，说明数据是当前这个事务更改的。
trx_id < min_trx_id	可以访问该版本	成立，说明数据已经提交了。
trx_id > max_trx_id	不可以访问该版本	成立，说明该事务是在ReadView生成后才开启。
min_trx_id <= trx_id <= max_trx_id	如果trx_id不在m_ids中，是可以访问该版本的	成立，说明数据已经提交。

不同的隔离级别，生成ReadView的时机不同：

• READ COMMITTED ：在事务中每一次执行快照读时生成ReadView。
• REPEATABLE READ：仅在事务中第一次执行快照读时生成ReadView，后续复用该ReadView。

两段锁协议（2PL）

保证事务串行化

两段锁协议（Two-Phase Locking――2PL）是保证并行事务可串行化的方法

1. 两段锁协议规定所有的事务应遵守的规则：
   ① 在对任何数据进行读、写操作之前，首先要申请并获得对该数据的封锁。
   　② 在释放一个封锁之后，事务不再申请和获得其它任何封锁。

2. 第一阶段是获得封锁的阶段，称为扩展阶段。第二阶段是释放封锁的阶段，称为收缩阶段。

3. 定理：若所有事务均遵守两段锁协议，则这些事务的所有交叉调度都是可串行化的。

当且仅当某组并发事务的交叉调度产生的结果和这些事务的某一串行调度的结果相同，则称这个交叉调度是可串行化。可串行化是并行事务正确性的准则。

同时我们必须指出，遵循两段锁协议的事务有可能发生死锁。
此时事务T1 、T2同时处于扩展阶段，两个事务都坚持请求加锁对方已经占有的数据，导致死锁。

为此，又有了一次封锁法。一次封锁法要求事务必须一次性将所有要使用的数据全部加锁，否则就不能继续执行。因此，一次封锁法遵守两段锁协议，但两段锁并不要求事务必须一次性将所有要使用的数据全部加锁，这一点与一次性封锁不同，这就是遵守两段锁协议仍可能发生死锁的原因所在。

知识贴：两段锁协议(2PL)

mysql的两阶段提交

binlog

二进制日志（BINLOG）记录了所有的 DDL（数据定义语言）语句和 DML（数据操纵语言）语句，但不包括数据查询（SELECT、SHOW）语句。

作用：①. 灾难时的数据恢复；②. MySQL的主从复制。

原因：主从同步问题

MySQL在修改数据时，MySQL是先从磁盘中将数据copy到内存，然后再将内存中的数据进行修改，并记录redo log buffer 然后在通过系统调用将事务日志写入磁盘redo log file 最后最后事务提交后将内存中修改后的数据在开始写入磁盘中。

先写binlog，再写redo log：当前事务提交后，写入binlog成功，之后主节点崩溃。在主节点重启后，由于没有写入redo log，因此不会恢复该条数据。而从节点依据binlog在本地回放后，会相对于主节点多出来一条数据，从而产生主从不一致。
先写redo log，再写binlog：当前事务提交后，写入redo log成功，之后主节点崩溃。在主节点重启后，主节点利用redo log进行恢复，就会相对于从节点多出来一条数据，造成主从数据不一致。

在两阶段提交的情况下，是怎么实现崩溃恢复的呢？

首先比较重要的一点是，在写入redo log时，会顺便记录XID，即当前事务id。在写入binlog时，也会写入XID。

1. 如果 redo log 已经 commit，那毫不犹豫的，把事务提交
2. 如果 redo log 处于 prepare，则根据XID找对应的 binlog ，找得到就提交，否则就回滚。
3. 两阶段提交，其实是为了保证 redo log 和 binlog 的逻辑一致性。

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