数据库系统第十一章 并发控制

第十一章 并发控制

前言
多用户数据库系统是指允许多个用户同时使用的数据库系统。其特点是在同一时刻并发运行的事务数可达数百上千个，多用户数据库系统涉及并行控制。

多事务执行方式
(1) 事务串行执行
每个时刻只有一个事务运行，其他事务必须等到这个事务结束以后方能运行

不能充分利用系统资源，发挥数据库共享资源的特点。

执行方式如下图：

image-20230209191031745

(2) 交叉并发方式
在单处理机系统中，事务的并行执行是这些并行事务的并行操作轮流交叉运行

单处理机系统中的并行事务并没有真正地并行运行，但能够减少处理机的空闲时间，提高系统的效率

执行方式如下图：

image-20230209191242809

T1运行的时候，T2读取T1不需要的资源，提高了效率

(3) 同时并发方式
多处理机系统中，每个处理机可以运行一个事务，多个处理机可以同时运行多个事务，实现多个事务真正的并行运行。

本章数据库系统并发控制技术是以单处理机系统为基础的。

(一) 并发控制概述

1. 并发控制机制的任务
   事务是并发控制的基本单位，并发控制机制的任务是：

对并发操作进行正确调度。

调度是指多个事务都要执行的时候，决定事务进行的先后顺序

保证事务的隔离性。

一个事务在运行的过程中，其他事务不允许访问其使用的资源

保证数据库的一致性。

并发操作带来数据的不一致性实例。

【例】飞机订票系统中的一个活动序列。

甲售票点（事务T1）读出某航班的机票余额A，设A=16；

乙售票点（事务T2）读出同一航班的机票余额A，也为16；

甲售票点卖出一张机票，修改余额A←A-1，所以A为15，把A写回数据库；

乙售票点也卖出一张机票，修改余额A←A-1，所以A为15，把A写回数据库。

同一时刻读取了统一数据，修改返回的时候也没有做任何限制

结果明明卖出两张机票，数据库中机票余额只减少1。

说明：

以上情况称为数据库的不一致性，是由并发操作引起的。在并发操作情况下，T1，T2两个事务的操作序列的调度是随机的。

若按上面的调度序列执行，T1事务的修改就被丢失。因为第4步中T2事务修改A并写回后覆盖了T1事务的修改。

并发操作带来的数据不一致性包括丢失修改、不可重复读、读“脏”数据。

用记号R（x）表示读数据X，W（x）表示写数据X。

2. 并发操作的数据不一致性
   (1) 丢失修改
   两个事务T1和T2读入同一数据并修改，T2的提交结果破坏了T1提交的结果，导致T1的修改被丢失。

上面飞机订票的例子就属此类。

时机 T1 T2 说明
① R(A)=16 ①时刻，T1读取了A数据为16
② R(A)=16 ②时刻，T₂读取了A数据为16
③ A←A-1 ③时刻，T₁对A-1并写回
W(A)=15
④ A←A-1 ④时刻，T₂对A-1并写回
W(A)=15
简单来说，就是在操作一个数据的过程中没有禁止其他事务读取该数据

由于两个事物数据的起始值一样，后执行的事务会覆盖掉先执行的事务

(2) 不可重复读
不可重复读是指事务T₁读取数据后，事务T₂执行更新（包括添加，修改，删除）操作，使T₁无法再现一次读取结果。
不可重复读包括三种情况：

事务T1读取某一数据后，事务T2对其做了修改，当事务T1再次读该数据时，得到与前一次不同的值。

时机 T1 T2 说明
① R(A)=50 T1读取B=100进行运算。
R(B)=100
求和=150
② R(B)=100 T2读取同一数据B，对其进行修改后将B=200写回数据库。
B←B*2
W(B)=200
③ R(A)=50 T1为了对读取值校对重读B，B为200，与第一次读取值不一致。
R(B)=200
求和=250
(验算不对)
幻读
幻读实际上是不可重复读的特殊例子，是

事务T₁按一定条件从数据库中读取了某些数据记录后，事务T₂删除了其中部分记录，当T₁再次按相同条件读取数据时，发现某些记录神秘地消失了。

事务T₁按一定条件从数据库中读取某些数据记录后，事务T₂插入了一些记录，当T₁再次按相同条件读取数据时，发现多了一些记录。

后两种不可重复读有时也称为幻影现象。

综上，不可重复读总的原因是自己在操作的时候允许别人修改

(3) 读“脏”数据
读“脏”数据是指读到不正确的数据。

事务T₁修改某一数据，并将其写回磁盘。

事务T₂读取同一数据后，T₁由于某种原因被撤销。

这时T₁已修改过的数据恢复原值，T₂读到的数据就与数据库中的数据不一致。

T₂读到的数据就为“脏”数据，即不正确的数据。

T1 T2
① R(C)=100
C←C*2
W(C)=200 T1将C值修改为200
② R(C)=200 T2读到C为200
③ ROLLBACK T1由于某种原因撤销，其修改作废，C恢复原值100
C恢复为100
这时T2读到C为200，与数据库内容不一致，就是“脏“数据
总结
上面三种数据不一致的情况主要是因为并发操作破坏了事务的隔离性。

并发控制就是要用正确的方式调度并发操作，使一个用户事务的执行不受其他事务的干扰，从而避免造成数据的不一致性。

对数据库的应用有时允许某些不一致性。

并发控制的主要技术：封锁、时间戳、乐观控制法、多版本并发控制。

简单用自己的话来解释三种

不一致性 说明 关键 补充
丢失修改 两个事物读取了相同的初始值，但是执行了不同的操作，后执行的操作覆盖了先执行的操作 读取初始值一样，后执行的覆盖了先执行的操作 写操作出问题
不可重复读 第一个事务读取了初始值，第二个事务紧接着修改了这个值，第一个事务再次读取时与原来的初始值不一样了 两次读取一个值的期间被改变了 读操作出问题
脏读 第一个事务写了数据，第二个事务读取改数据，但是第一个事务又回滚了，则第二个事务读取到的就是错误的数据
引起问题的原因就是回滚 在数据被写入和回滚的期间读取了数据 读操作出问题
(二) 封锁

1. 什么是封锁
   封锁就是事务T在对某个数据对象（例如表、记录等）操作之前，先向系统发出请求，对其加锁。加锁后事务T就对该数据对象有了一定的控制，在事务T释放它的锁之前，其它的事务不能更新此数据对象。

说明

重点 说明
先向系统发出请求 1. 这个系统不是操作系统，是数据库管理系统
2. 进行操作之前都要先向系统发出请求，只有请求通过才能进行操作；如果数据已经被加锁了，对应的操作就不被允许，只能等待
对其加锁 请求通过后就会对数据加锁，不同的请求对应不同的锁
一定的控制 请求通过并不是说数据完全归请求发出者，有可能允许别的事务读取
其它的事务不能更新此数据对象 不论是什么锁，更新（增删改）是一定不允许的，读取可能允许
封锁是实现并发控制的一个非常重要的技术。

2. 基本封锁类型
   一个事务对某个数据对象加锁后究竟拥有什么样的控制由封锁的类型决定。

基本封锁类型：排它锁（简记为X锁）、共享锁（简记为S锁）。

(1) 排它锁(X锁)
排它锁又称为写锁，若事务T对数据对象A加上X锁，则只允许T读取和修改A，其它任何事务都不能再对A加任何类型的锁，直到T释放A上的锁，保证其他事务在T释放A上的锁之前不能再读取和修改A

一般执行写操作(增删改)操作的时候会加X锁，因此成为写锁

(2) 共享锁(S锁)
共享锁又称为读锁，若事务T对数据对象A加上S锁，则事务T可以读A但不能修改A，其它事务只能再对A加锁，而不能加X锁，直到T释放A上的锁。保证其他事务可以读A，但在T释放A上的S锁之前不能对A做任何修改。

在进行读数据的请求的时候会加读锁

3. 锁的相容矩阵
   T₁→
   T₂ ↓ X S _
   X N N Y
   S N Y Y
   _ Y Y Y
   Y=Yes，相容的请求，N=No，不相容的请求

在锁的相容矩阵中：

最左边一列表示事务T1已经获得的数据对象上的锁的类型，其中横线表示没有加锁。

最上面一行表示另一事务T2对同一数据对象发出封锁请求。

T2的封锁请求与T1已持有的锁相容，封锁请求可以满足。

N表示T2的封锁请求与T1已持有的锁冲突，T2的请求被拒绝。

总结，数据一旦被加上X锁，就不允许加其他锁了；其他情况都可以加锁

(三) 封锁协议
什么是封锁协议
封锁协议是指在运用X锁和S锁对数据对象加锁时，需要约定一些规则，这些规则为封锁协议，例如何时申请X锁或S锁、持锁时间、何时释放等。

封锁协议研究的就是这三个

对封锁方式规定不同的规则，就形成了各种不同的封锁协议，它们分别在不同的程度上为并发操作的正确调度提供一定的保证。本章主要介绍三级封锁协议。

1. 一级封锁协议
   (1) 加锁解锁时间
   一级封锁协议是指事务T在修改数据R之前必须先对其加X锁，直到事务结束才释放；

事务结束包括正常结束和非正常结束。

这个修改数据R包括读取数据R，因此才能解决丢失修改

(2) 一级封锁协议作用
一级封锁协议可防止丢失修改，并保证事务T可恢复。

在一级封锁协议中，如果仅仅是读数据不对其进行修改，是不需要加锁的，所以它不能保证可重复读和不读“脏”数据。

读数据的时候不会封锁，因此会造成可重复读和脏读

(3) 解决丢失修改的问题
时机 T1 T2 说明
① Xlock A 事务T1在读A进行修改之前先对A加X锁
② R(A)=16
Xlock A T2请求对A加X锁被拒绝
③ A←A-1 等待 T2只能等待T1释放A上的锁后获得对A的X锁
W(A)=15 等待 在这个期间T₂每个时间段都会向系统发出请求
Commit 等待 T₁提交事务
Unlock A 等待 事物提交之后解锁
④ 获得Xlock A
R(A)=15 这时T2读到的A已经是T1更新过的值15
A←A-1
⑤ W(A)=14 T2按新的A值进行运算，并将结果值A=14写回到磁盘。避免了丢失T1的更新。
Commit
Unlock A
2. 二级封锁协议
(1) 加锁解锁时间
二级封锁协议是一级封锁协议加上事务T在读取数据R之前必须先对其加S锁，读完后即可释放S锁。

读完之后立即释放了，因此可能在别的数据

(2) 二级封锁协议作用
二级封锁协议可以防止丢失修改和读“脏”数据。

在二级封锁协议中，由于读完数据后即可释放S锁，所以它不能保证可重复读。

防止读脏数据是因为在读取数据的时候会申请加锁，如果此时别的数据还没有提交，就有可能回滚，因此此时申请不会通过

(3) 解决读“脏”数据问题
时机 T1 T2 说明
① Xlock C 事务T1对C进行修改之前，先对C加X锁
R(C)=100
C←C*2 修改后写回磁盘。
W(C)=200
② Slock C T2请求在C上加S锁，因T1已在C上加了X锁，T2只能等待。
等待
③ ROLLBACK 等待 T1因某种原因被撤销
(C恢复为100) 等待 C恢复为原值100
Unlock C 等待 T1释放C上的X锁后
④ 获得Slock C T2获得C上的S锁
R(C)=100 读C=100。避免了T2读“脏”数据
⑤ Commit C
Unlock C
解决读脏数据，起作用的是发出请求加锁，而不是加锁后的结果，因为请求被拒绝了，所以不会读到脏数据

3. 三级封锁协议
   (1) 加锁解锁时间
   三级封锁协议是一级封锁协议加上事务T在读取数据R之前必须先对其加S锁，直到事务结束才释放。

(2) 三级封锁协议作用
三级封锁协议作用：三级封锁协议可防止丢失修改、读脏数据和不可重复读。

与二级封锁协议不同的是，事务结束才释放S锁，而不是读取完后就能释放

(3) 解决不可重复读问题
T1 T2
① Slock A
Slock B
R(A)=50
R(B)=100
求和=150
② Xlock B
等待
③ R(A)=50 等待
R(B)=100 等待
求和=150 等待
Commit 等待
Unlock A 等待
Unlock B 等待
④ 获得XlockB
R(B)=100
B←B*2
⑤ W(B)=200
Commit
Unlock B
事务T1在读A、B之前，先对A、B加S锁。

其他事务只能对A、B加S锁，而不能加X锁，即其他事务只能读A、B，而不能修改。

T2修改B而申请对B的X锁时被拒绝需等待T1释放B上的锁。

T1为验算再读A、B，这时读出的B仍是100，求和结果仍为150，即可重复读。

T1结束释放A、B上的S锁。T2才获得对B的X锁。

小结
三级协议的主要区别是什么操作需要申请封锁一级何时释放锁（即持锁时间）。

不同的封锁协议使事务达到的一致性级别不同，封锁协议级别越高，一致性程度越高。

解决不一致问题，不仅仅依靠的是加锁后禁止其他事务操作，还包括自己申请加锁后被拒绝从而防止自己进行操作，比如解决脏读

X锁 S锁 一致性保证
操作结束释放 事务结束释放 操作结束释放 事务结束释放 不丢失 修改 不读“脏”数据 可重复 读
一级封锁协议 √ √
二级封锁协议 √ √ √ √
三级封锁协议 √ √ √ √ √

(四) 活锁和死锁
封锁技术可以有效地解决并行操作的一致性问题，但也带来一些新的问题

1. 活锁
   (1) 什么是活锁
   例：以下事务的执行是活锁的情形。

事务T₁封锁了数据R。

事务T₂又请求封锁R，于是T₂等待。

T₃也请求封锁R，当T₁释放了R上的封锁之后系统首先批准了T₃的请求，T₂仍然等待。

T₄又请求封锁R，当T₃释放了R上的封锁之后系统又批准了T₄的请求…。

T₂有可能永远等待，这就是活锁的情形。

T1 T2 T3 T4
Lock R • • • • • • • • •
• Lock R
• 等待 Lock R
• 等待 • Lock R
Unlock R 等待 • 等待
等待 Lock R 等待
• 等待 • 等待
• 等待 Unlock 等待
• 等待 • Lock R
等待 • • •
(2) 避免活锁
采用先来先服务的策略。

即当多个事务请求封锁同一数据对象时按请求封锁的先后次序对这些事务排队，该数据对象上的锁一旦释放，首先批准申请队列中第一个事务获得锁。

也可以采用优先级，优先级可以有请求发出的顺序或者事务的紧急性决定

2. 死锁
   (1) 什么是死锁
   例：以下事务的执行是死锁的情形

事务T₁封锁了数据R₁。

T₂封锁了数据R₂。

T₁请求封锁R₂，因T₂已封锁了R₂，于是T₁等待T₂释放R₂的锁。

接着T₂又申请封锁R₁，因T₁已封锁了R₁，T₂也只能等待T₁释放R₁上的锁。

这样T₁在等待T₂，而T₂又在等待T₁，T₁和T₂两个事务永远不能结束，形成死锁。

多个事务互相请求彼此锁住的数据

T1 T2
Lock R1 • • •
• Lock R2
• • • •
Lock R2 •
等待
等待
等待 Lock R1
等待 等待
等待 等待
• • •
(2) 解决死锁的办法
解决死锁的方法：死锁的预防和死锁的诊断与解除。

死锁的预防
产生死锁的原因是两个或多个事务都已封锁了一些数据对象，然后又都请求对已为其他事务封锁的数据对象加锁，从而出现死等待。

预防死锁的发生就是要破坏产生死锁的条件，主要的方法有一次封锁法、顺序封锁法。

a. 一次封锁法

要求每个事务必须一次将所有要使用的数据全部加锁，否则就不能继续执行。
存在的问题：

降低系统并发度。（可能当前事务不使用的数据，别的事务也不能使用）

难于事先精确确定封锁对象。

b. 顺序封锁法
预先对数据对象规定一个封锁顺序，所有事务都按这个顺序实行封锁。
存在的问题：

维护成本高

数据库系统中封锁的数据对象多，且随数据的插入、删除等操作而不断变化，维护这样的资源的封锁顺序非常困难，成本很高。

难以实现

事务的封锁请求可以随着事务的执行而动态地决定，很难事先确定每一个事务要封锁哪些对象，因此也就很难按规定的顺序去施加封锁。

结论
在操作系统中广为采用的预防死锁的策略并不太适合数据库的特点。

数据库管理系统在解决死锁的问题上更普遍采用的是诊断并解除死锁的方法。

死锁的诊断与解除
死锁诊断的方法主要有超时法和等待图法。

a. 超时法
如果事务的等待时间超过了规定的时限，就认为发生了死锁。

优点：实现简单。

缺点：

一是有可能误判死锁；

二是时限若设置得太长，死锁发生后不能及时发现。

b. 等待图法
用事务等待图动态反映所有事务的等待情况，事务等待图是一个有向图G=（T，U），其中：

T为结点的集合，每个结点表示正运行的事务。

U为边的集合，每条边表示事务等待的情况。

若T1等待T2，则T1，T2之间划一条有向边，从T1指向T2。

例：

图（a）中，事务T1等待T2，T2等待T1，产生了死锁。

图（b）中，事务T1等待T2，T2等待T3，T3等待T4，T4等待T1，产生了死锁。

图（b）中，事务T3可能还等待T2，在大回路中又有小的回路。

image-20230211104757930

这个方法很巧妙啊，在设计进程锁的问题可以学习

如果有环就表明有死锁

说明：

并发控制子系统周期性（比如每隔数秒）生成事务等待图，检测事务。如果发现图中存在回路，则表示系统中出现了死锁。

解除死锁的方法是选择一个处理死锁代价最小的事务，将其撤销，释放此事务持有的所有的锁，使其它事务能继续运行下去。

(五) 并发调度的可串行性
前面介绍的是防止操作不一致的方法；本节介绍正确的调度结果是什么，也就是如何判断一个并发调度的结果是正确的

数据库管理系统对并发事务不同的调度会产生不同的结果，什么样的调度是正确的呢？

串行调度是正确的，执行结果等价于串行调度的并发调度也是正确的，称为可串行化调度。

1. 可串行化调度
   可串行化调度：多个事务并发执行是正确的，当且仅当其结果与按某一次序串行地执行这些事务时的结果相同。

可串行性：是并发事务正确调度的准则，按照这个准则一个给定的并发调度，当且仅当它是可串行化的，才认为是正确调度。

例：现在有两个事务，分别包含下列操作：

事务T₁：读A；A=B+1；写回A。

事务T₂：读A；B=A+1；写回B。

这两个事务的不同调度策略如下：

调度策略1：

假设A、B的初值均为2。

按T₁→T₂次序执行结果为A=3，B=4。

串行调度策略，正确的调度。

T₁ T₂ 说明
Slock B 在读取之间加R锁
Y=R(B)=2
Unlock B 读取之后解锁
Xlock A 在写之前加X锁
A=Y+1=3
W(A)
Unlock A 写之后解锁
Slock A
X=R(A)=3
Unlock A
Xlock B
B=X+1=4
W(B)
Unlock B
调度策略2：

假设A、B的初值均为2。

按T₂→T₁次序执行结果为A=4，B=3。

串行调度策略，正确的调度。

T₁ T₂
Slock A
X=R(A)=2
Unlock A
Xlock B
B=X+1=3
W(B)
Unlock B
Slock B
Y=R(B)=3
Unlock B
Xlock A
A=Y+1=4
W(A)
Unlock A
我们认为，只有这两种串行调度的结果，即：

A = 3 且 B = 4

或

A = 4 且 B = 3

只有这两种结果的并行调度，结果是正确的，这种调度才叫可串行化的

我们看以下的调度

调度策略3：

T₁ T₂
Slock B
Y=R(B)=2
Slock A
X=R(A)=2
Unlock B
Unlock A
Xlock A
A=Y+1=3
W(A)
Xlock B
B=X+1=3
W(B)
Unlock A
Unlock B
执行结果与1、2都不同，是错误的调度。

调度策略4：

T₁ T~2 ~
Slock B
Y=R(B)=2
Unlock B
Xlock A
Slock A
A=Y+1=3 等待
W(A) 等待
Unlock A 等待
X=R(A)=3
Unlock A
Xlock B
B=X+1=4
W(B)
Unlock B
执行结果与串行调度①的执行结果相同，是正确的调度。

2. 冲突可串行化的调度
   (1) 冲突可串行化和冲突操作
   本节介绍如何判断一个调度是可串行化的调度

冲突可串行化：

一个比可串行化更严格的条件

·商用系统中的调度器采用

冲突操作：是指不同的事务对同一数据的读写操作和写写操作：

R_i(x)与W_j(x) /事务T_i读x，T_j写x，其中i≠j/

先写后读和先读后写的结果肯定不一样，所以不能调换

W_i(x)与W_j(x) /事务T_i写x，T_j写x，其中i≠j/

两次写的顺序也决定最终的结果

其他操作是不冲突操作(其他操作也就是不同的事务对同一数据的读读操作了)

说明：

除读写操作和写写操作外，其他操作是不冲突操作。

不同事务的冲突操作和同一事务的两个操作是不能交换的。

Ri（x）与Wj（x）改变执行次序，则Ti读x的数据将发生变化。

Wi（x）与Wj（x）改变执行次序，则x的数据由等于T_j的结果，变为了Ti的结果。

并发调度主要研究是多个事务并发操作数据库的问题，因此不考虑同一事物的操作

后面主要是考虑多个事务的操作

(2) 如何判断冲突可串行化
一个调度Sc在保证冲突操作的次序不变的情况下，通过交换两个事务不冲突操作的次序得到另一个调度Sc’，如果Sc’是串行的，称调度Sc是冲突可串行化的调度。

不交换一个事务的操作

若一个调度是冲突可串行化的调度，可用这种方法判断一个调度是否是冲突可串行化的。

【例】今有调度

Sc₁=r₁(A)w₁(A)r₂(A)w₂(A)r₁(B)w₁(B)r₂(B)w₂(B)（忽略了加锁和解锁的操作）

判断是不是可串行化的操作

找到冲突操作r₂(A)w₂(A)、r₁(B)w₁(B)，这都是两个事务对统一数据的冲突操作

更改的目的是要更改为串行操作

交换r₂(A) 和 w₁(B)，得到

r₁(A)w₁(A)w₁(B)w₂(A) r₁(B)r₂(A)r₂(B)w₂(B)

在交换r₂(A)和r₁(B)w₁(B)，得到

Sc2=r1(A)w1(A)r1(B)w1(B) r2(A)w2(A)r2(B)w2(B)

最终交换的目的就是T₁写到一块，T₂写到一块

这样就是T₁→T₂的串行操作，所以Sc1冲突可串行化的调度

冲突可串行化调度是可串行化调度的充分条件，但不是必要条件。还有不满足冲突可串行化的可串行化调度。

【例】有3个事务

T₁=W₁(Y)W₁(X)，T₂=W₂(Y)W₂(X)，T₃=W₃(X)

调度L1=W₁(Y)W₁(X) W₂(Y)W₂(X) W₃(X)是一个串行调度。

调度L₂= W₁(Y)W₂(Y)W₂(X)W₁(X)W₃(X) 不满足冲突可串行化。

但是调度L₂是可串行化的，因为L2执行的结果与调度L₁相同，Y的值都等于T₂的值，X的值都等于T₃的值

已知有W₁(X)，找冲突操作就是W₂(X)或者R₂(X)，如果没有就是没有冲突操作

如何找不冲突操作：

已知有R₁(X)，那么可以找R₂(X)，W₃(Y)，这些

只要下表不一样，并且不属于冲突操作的就是不冲突操作

这些不冲突操作可以更改顺序的

(六) 两段锁协议
两段锁协议保证的是并发调度的正确性

数据库管理系统普遍采用两段锁协议的方法实现并发调度的可串行性，从而保证调度的正确性。

1. 两段锁协议定义
   两段锁协议定义：指所有事务必须分两个阶段对数据项加锁和解锁，即

在对任何数据进行读、写操作之前，事务首先要获得对该数据的封锁；

在释放一个封锁之后，事务不再申请和获得任何其他封锁。

两段锁的含义：事务分为两个阶段。

第一阶段是获得封锁，也称为扩展阶段。事务可以申请获得任何数据项上的任何类型的锁，但是不能释放任何锁。

第二阶段是释放封锁，也称为收缩阶段。事务可以释放任何数据项上的任何类型的锁，，但是不能再申请任何锁。

【例】

事务T_i遵守两段锁协议，其封锁序列是 ：

Slock A Slock B Xlock C Unlock B Unlock A Unlock C；

事务T_j不遵守两段锁协议，其封锁序列是：

Slock A Unlock A Slock B Xlock C Unlock C Unlock B；

T₁ T₂
Slock A
R(A)=260
Slock C
R(C)=300
Xlock A
W(A)=160
Xlock C
W(C)=250
Slock A
Slock B 等待
R(B)=1000 等待
Xlock B 等待
W(B)=1100 等待
Unlock A 等待
R(A)=160
Xlock A
Unlock B
W(A)=210
Unlock C
上的调度是遵守两段锁协议的，因此一定是一个可行化调度。

【验证】忽略图中加锁操作和解锁操作，按照时间先后次序得到如下调度:

L₁ =R₁(A)R₂(C)W₁(A)W₂(C)R₁(B)W₁(B)R₂(A)W₂(A)

先转换R₂(C)和W₁(A)，然后转换R₁(A)W₁(A)与R₂(C)W₂(C)

可以如果两个事物的组合操作不是冲突的话，可以组合交换

L₂ =R₁(A)W₁(A)R₁(B)W₁(B) R₂(C)W₂(C)R₂(A)W₂(A)

2. 说明
   事务遵守两段锁协议是可串行化调度的充分条件，而不是必要条件。

若并发事务都遵守两段锁协议，则对这些事务的任何并发调度策略都是可串行化的

若并发事务的一个调度是可串行化的，不一定所有事务都符合两段锁协议

3. 两段锁协议 & 一次封锁法
   前面防止死锁有一次封锁法

一次封锁法要求每个事务必须一次将所有要使用的数据全部加锁，否则就不能继续执行，因此一次封锁法遵守两段锁协议。

两段锁协议并不要求事务必须一次将所有要使用的数据全部加锁，因此遵守两段锁的事务可能发生死锁。

(七) 封锁的粒度
粒度一般是指大小，比如封锁是封一个数据，还是一条记录，还是一个表，还是一个数据库

概念
封锁对象的大小称为封锁粒度。

封锁的对象：逻辑单元，物理单元。

逻辑单元：属性值、属性值的集合、元组、关系、索引项、整个索引、整个数据库等。

物理单元：页（数据项或索引页）、物理记录等。

粒度和并发度与开销的关系
说明：

封锁粒度与系统的并发度和并发控制的开销密切相关。

封锁的粒度越大，数据库所能够封锁的数据单元就越少，并发度就越小，系统开销也越小。

封锁的粒度越小，并发度较高，但系统开销也就越大。

例：

若封锁粒度是数据页：

事务T₁需要修改元组L₁，则T₁必须对包含L₁的整个数据页A加锁。若T₁对A加锁后事务T₂要修改A中元组L₂，则T₂被迫等待，直到T₁释放A。

若封锁粒度是元组：

则T₁和T₂可以同时对L₁和L₂加锁，不需要互相等待，提高了系统的并发度。

又如，事务T需要读取整个表，T必须对表中的每一个元组加锁，开销极大。

1. 多粒度封锁
   (1) 定义
   多粒度封锁是指在一个系统中同时支持多种封锁粒度供不同的事务选择。

(2) 多粒度封锁原则
选择封锁粒度的原则----考虑封锁开销和并发度两个因素，具体为：

处理多个关系的大量元组的用户事务：以数据库为封锁单位。（因为涉及多个关系）

处理大量元组的用户事务：以关系为封锁单元。

只处理少量元组的用户事务：以元组为封锁单位。

(3) 多粒度树
多粒度树：以树形结构来表示多级封锁粒度

根结点是整个数据库，表示最大的数据粒度

叶结点表示最小的数据粒度。

例：三级粒度树根节点为数据库，数据库的子结点为关系，关系的子结点为元组。

image-20230211151401858

建立多粒度树的目的是为了后面的多粒度封锁协议

这个值得学习

(4) 多粒度封锁协议
允许多粒度树中的每个结点被独立地加锁，对一个结点加锁意味着这个结点的所有后裔结点也被加以同样类型的锁。

在多粒度封锁中一个数据对象可能以两种方式封锁：显式封锁和隐式封锁。

显式封锁：直接加到数据对象上的封锁。

隐式封锁：是该数据对象没有独立加锁，是由于其上级结点加锁而使该数据对象加上了锁。

显式封锁和隐式封锁的效果是一样的，系统检查封锁冲突时要检查显式封锁还要检查隐式封锁。

【例】事务T要对关系R₁加X锁。

系统必须搜索其上级结点数据库、关系R1，还要搜索R1的下级结点，即R1中的每一个元组

如果其中某一个数据对象已经加了不相容锁，则T必须等待。（锁还是可以加的，只是要看加的类型是否与当前的锁相容）

说明：

对某个数据对象加锁，系统要检查：

该数据对象：有无显示封锁与之冲突。

所有上级结点：检查本事务的显示封锁是否与该数据对象上的隐式封锁冲突（由上级结点已加的封锁造成的）。

所有下级结点：看上面的显示封锁是否与本事务的隐式封锁（将加到下级结点的封锁）冲突。

比如要对student表加锁

先要看student表有无显示封锁

然后看数据库有无冲突隐式封锁（可能数据库的其他表加锁而给了数据库隐式封锁锁）

然后看student表的所有元组有无给student表添加隐式封锁，比如student表中的张三进行封锁之后，student表也加锁了

但是只用多粒度封锁影响效率，比如如果student有1w个元组，就要每个元组都遍历

2. 意向锁
   (1) 意向锁的目的
   引进意向锁目的：提高对某个数据对象加锁时系统的检查效率。（不需要遍历一个表的所有元组了）

(2) 意向锁的含义
意向锁的含义：

如果对一个结点加意向锁，则说明该结点的下层结点正在被加锁。

对任一结点加基本锁，必须先对它的上层结点加意向锁。

【例】对任一元组加锁时，必须先对它所在的数据库和关系加意向锁。

(3) 常用意向锁的分类
移向共享锁（Intent Share Lock，简称IS锁）。

意向排它锁（Intent Exclusive Lock，简称IX锁）。

共享意向排它锁（Share Intent Exclusive Lock，简称SIX锁）。

IS锁
IS锁：如果对一个数据对象加IS锁，表示它的后裔结点拟（意向）加S锁。

应该这样说，对一个数据加S锁，要多其所有父节点加IS锁，这样查看父节点就可以知道这个父节点中有数据加了S锁。但不是全部都加了S锁

例：事务T₁要对R₁中某个元组加S锁，则要首先对关系R1和数据库加IS锁。

IX锁
IX锁：如果对一个数据对象加IX锁，表示它的后裔结点拟（意向）加IX锁。
例：事务T₁要对R₁中某个元组加X锁，则要首先对关系R1和数据库加IX锁。

SIX锁
不是ISX

SIX锁：如果对一个数据对象加SIX锁，表示对它加S锁，再加IX锁，即SIX=S+IX。

例：对某个表加SIX锁，则表示该事务要读整个表（所以要对该表加S锁），同时会更新个别元组（所以要对该表加IX锁）。

对一个表加了S锁表示读取整个表，加了IX锁表示表中有数据要修改

(4) 意向锁的相容矩阵
image-20230211152814510

简要解释一下，认为这个加锁的对象是关系，认为是数据库也行

T₁加了S锁说明T₁正在读这个表（中的所有数据），此时

允许T₂读，即可以加S锁；允许T₂读表中的数据，即可以加IS锁

但是不允许T₂修改这个表或者修改这个表中的所有数据，因此不能加X锁，IX锁，SIX锁

T₁加了X锁说明T₁正在修改这个表，此时

不允许T₂修改这个表，也不允许T₂看这个表，因此什么锁都不能加

T₁加了了IS锁说明T₁正在读取表中的某个元组，此时

允许T₂读这个表，即可以加S锁，允许T₂读表中的某个元组，即可以加IS锁

允许T₂修改这个表中的部分元组(当然不是T₁读取的元组)，即可以加IX锁，SIX锁

但是不允许T₂修改整个表

T₁加了IX锁说明T₁正在修改表中的某个元组，此时：

允许T₂修改表中的某个元组，即可以加IX锁；允许T₂查看某个元组，可以加IS锁

但是不允许T₂查看，修改整个表，即不可以加S，X，SIX锁

T₁加了SIX锁，表示T₁正在查看这个表，并且修改表中的某个元组，此时

允许T₂查看表中的某个元组，即可以加IS锁

但是不允许T₂修改表，修改表中的元组，查看表，即不能加X锁，IX锁，SIX锁，S锁

(5) 锁的强度
锁的强度：是指它对其他锁的排斥程度，一个事务在申请封锁时以强锁代替弱锁是安全的，反之则不然。

就是一个事务进行加锁时，强的锁会覆盖弱的锁

锁的强度的偏序关系

image-20230211153627897

比如T₁已经对关系R₁加了SIX锁了，那么加X锁就会覆盖SIX锁，但是不允许加IS锁

(6) 具有意向锁的多粒度封锁方法
任何事务T要对一个数据对象加锁，申请封锁时应该按自上而下的次序进行，释放封锁时则应该按自下而上的次序进行。
例：事务T1要对关系R1加S锁。

对数据库加IS锁。

检查数据库和R₁是否已加了不相容的锁（X或IX）。

不再需要搜索和检查R1中的元组是否加了不相容的锁（X）锁。

(八) 其他并发控制机制
1* 时间戳方法
给每个事务盖上一个时表标，即事务开始执行的时间。（一个事务是会有多个操作的）
控制机制：

各事务具有唯一时间戳，并按照这个时间戳解决冲突。

如冲突则回滚具有较早时间戳的事务。

回滚的事务赋予新的时间戳并从头开始执行。

2* 乐观控制法
又称验证方法，乐观控制法认为事务执行时间很少发生冲突，因此不对事务进行特殊管制（比如加锁）。
控制机制：

不对事务进行特殊管制，让它自由执行，事务提交前再进行准确性检查。

如果检查后发现该事务的执行出现冲突并影响了可串行性则拒绝提交并回滚事务。

就是前期随便做，最后提交的时候检查；检查出错误前期全部白做

3. 多版本并发控制(MVCC)
   (1) 概念
   多版本并发控制（MVCC）
   是指在数据库中通过维护数据库对象的多个版本信息来实现高效并发控制的一种策略。

版本的定义

是指数据库中对象的一个快照，记录了数据对象某个时刻的状态。

计算机存储设备价格降低，可以考虑为数据库系统的数据对象保留多个版本，以提高系统的并发操作。

因为保存多个版本需要大量的硬盘空间，因为硬盘降价才得以实现

【例】有一个数据对象A有两个事务，其中T1是写事务，T2是读事务。封锁方法和多版本并发控制方法对比如下：

封锁方法

image-20230211162237512

可以看到T₁已经Xlock A了，T₂进行Slock A的时候就会等待

MVCC方法

image-20230211162349518

读写不必要等待，由此提高了并发性

(2) 多版本并发控制协议
每个write（Q）创建一个新版本Q_m，形成一个版本序列Q₁，Q₂，Q₃，…，Q_m。

每个版本Qk包括三个数据：

数据 说明
版本值 数值
创建Q_k事务的时间戳W-timestamp(Q_k) 就是创建Q_k的时间
W-timestamp（Q）表示数据项Q上成功执行Write（Q）操作的所有事务中的最大时间戳。
成功读取Q_k事务的最大时间戳R-timestamp(Q_k) R-timestamp（Q）表示数据项Q上成功执行Read（Q）操作的所有事务中的最大时间戳
就是最后一次读取Q_k的时间
事务创建的时间戳

用TS(T)表示事务T的时间戳，TS(T_i)<TS(T_j)表示事务T_i在事务T_j之前开始执行。

事务会有多个操作的，时间戳表示事务创建或者开始的时间

协议描述如下：

假设版本Q_k具有小于或等于TS(T)的最大时间戳。

可能小于，比如Q_k是在T事务之前写的

可能等于，比如Q_k的写与T在同一时间发送

若事务T发出Read（Q），则返回版本Q_k的内容。

（读操作不需要考虑）

若事务T发出Write（Q），则判断：

当TS（T）<R-timestamp（Qk）时，回滚T；

当事务写的时间戳小于最后一次读的时间戳时，说明在后面已经有人在写了

当TS（T）=W-timestamp（Qk）时，覆盖Qk的内容。

同时写的话会覆盖

否则，创建Q的新版本。

读的时候无所谓，写的时候看情况

若一个数据对象的两个版本Q_k和Q₁，其中W-timestamp都小于系统中最老的时间戳，则删除Q_k和Q₁中旧的那个版本。(这是为了防止版本过多)

(3) 优点和缺点
MVCC和封锁机制相比，消除了数据库中数据对象读和写操作的冲突，有效提高系统的性能。

MVCC会产生大量无效版本，而且在结束事务时刻，其所影响的元组的有效性不能马上确定。

4. 改进的多版本并发控制
   (1) 定义
   改进多版本并发控制
   将事务分为只读事务和更新事务。

MV2PL协议
只读事务发生冲突的可能性很小，采用多版本时间戳。
更新事务采用较保守的两阶段封锁（2PL）协议。

就是将两种协议融合起来

验证锁（C锁）
除了传统的读锁（共享锁）和写锁（排他锁），引入验证锁（C锁），封锁的相容矩阵如下图：

(2) 封锁的相容矩阵
封锁的相容矩阵

R-Lock W-Lock C-Lock
R-Lock Y Y N
W-Lock Y N N
C-Lock Y N N
C-Lock是在提交之前先对数据加锁进行验证，验证通过即可提交事务

所以C-Lock的时候是进制其他锁的

在多版本并发控制中，读和写操作不再冲突，可以同事加锁（比如先读后写，读就读的旧版本，写写的新版本；先写后读也没问题）

不能同时写

说明
在该方法中读锁和写锁相容了，写形成新的版本，读则读旧版本。

写事务提交时，首先要获得验证锁，获得验证锁后系统就可以丢掉旧值。

MV2PL的好处在于读锁和写锁不冲突，有效提高系统并发性。

小结
数据库的并发控制以事务为单位，通常使用封锁机制。
最常用的封锁方法和三级封锁协议。

并发控制机制
并发控制机制调度事务正确性的判断准则是可串行性。
并发操作的正确性则通常由两段锁协议来保证。

其他并发控制机制
时间戳方法、乐观控制法、多版本并发控制。