数据库三级封锁协议简述

 

免费chatgpt使用网址 http://ffff.chat:2023  在设置中设置userID

 

 

我们首先来简单了解一下事务：事务首先是定义一组操作集，这组操作集要么都做，要么都不做。

比如A向B转账100元，操作集为 （1）读取A账户金额

　　　　　　　　　　　　　　（2）A账户金额  -  100元

　　　　　　　　　　　　　　（3）读取B账户金额

　　　　　　　　　　　　　　（4）B账户金额 + 100元

如果这组操作集，没有都执行完，只执行了几条语句，就会导致数据库数据不一致性，钱不翼而飞了。

 

三级封锁协议，就是在高并发环境下，有多个事务同时执行，保证数据的一致性。一，二，三级协议分别解决了，丢失修改，读脏数据，和不可重复读问题。

1.首先我们来介绍一下基本封锁类型，就是人为的定义的规则，我们必须先知道规则。

锁的类型：

X锁: （Exclusive Locks）排它锁，简记为X锁。

S锁:（Share Locks）共享锁，简记为S锁。

规则如下：①如果一个事务对 数据A加上了X锁，则不再允许其他事务加X锁或者S锁（两把锁都不能加）。

　　　　　②如果一个事务对 数据A加上了S锁，那么其他事务不能对该事务加X锁，可以对事务加S锁（可以加一把S锁）。

记住这两条规则，就可以生成一个锁的相容矩阵：

　　　　　　一个事务对数据A加上了 X锁，那么另外一个事务对数据A，不能加X锁，不能加S锁。

　　　　　　一个事务对数据A加上了S锁，那么另外一个事务对数据A，不能加X锁，可以加S锁。

 

2.了解了以上规则之后我们就来看三个案例：T1,T2 表示两个不同的事务，CPU在调度时，可以分配时间片给T1，T2执行，什么时候执行哪个事务的哪条语句是不确定的。其中R（x）表示从数据库读取x，W（x）表示往数据库写X。

                   T1                                    T2            

①时刻     R(A) = 100

②时刻　　　　　　　　              R(A) = 100

③时刻     A = 100 -10

④时刻　　　　　　　　　　      R(A) = 100 - 30

⑤时刻    W(A) = 90

⑥时刻　　　　　　　　　      　W(A) = 70

 

这就出现问题了，明明两个事务先  减10 ，再减30，总数应该是减40 ，结果为 60，这时候就发生了修改丢失。T1事务对A数据的修改丢失了。

 

 

 

重点来了，重点来了，重点来了!!!   这时候来介绍数据库封锁一级协议

协议规则如下：

一个事务对数据修改，需要加上X锁，直到这个事务结束，才把X锁释放。

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13

T1                                             T2             ①时刻     Lock(A) //请求对A加锁      ②时刻    R(A) = 100，A = 100 -10   ，W(A) = 90                     等待 // 请求修改A，对A加锁，但是T1加的是X锁，其他事务不能再加锁，只能等待      ③时刻     Ulock(A)//释放X锁                                        等待   ④时刻　　　　　　　　　                    　                        Lock（A）    //获得A锁   ⑤时刻              　　　　　　　　　　　　　　　　　　　　　　　　　　　  R（A）= 90，A=90-30，W（A）= 60                               　　   ⑥时刻　　　                   　　　　　　　　　　　　　　　　　　　  　  Ulock(A)

　　

以上就是一级协议

3.接下来介绍二级封锁协议的规则如下：

　　当一个事务写数据A时，需要加上X锁，当一个事务读数据A时，需要加上S锁读完立即释放S锁。

例如下面这个读“脏”数据的 例子，看两个事务会出现什么问题

                         T1                        T2           

　　　　  

①时刻     Lock(A)

②时刻　   R(A) = 100，A  = 100 -10，W(A) = 90　　　　              

③时刻      　　　　　　　　　　　　　　　　　　　　　　R(A) = 90

④时刻　　 rollback　　　　　　　                                            

⑤时刻    Unlock(A)

⑥时刻　  恢复A = 100　　　　 

T1事务先修改了A数据为90，然后T2事务读取到了数据90，但是后来T1 回滚了，而T2读到了错误的数据，这称为读“脏”数据。

而根据二级封锁协议规定，在读数据之前需要请求 S 加锁，则如下面：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

T1                                   T2             ①时刻      Lock（A）   ②时刻　  R(A) = 100， A  = 100 -10，W(A) = 90　　　                ③时刻     　　　　　　　　　　　                          //请求加S锁，但是此时A加了X锁，不能加S锁，只能等待   ④时刻　　　　　　　　　　                                   等待   ⑤时刻   RollBack　  　　　　　　　                         等待   　　　　  Unlock(A)   ⑥时刻　 恢复A= 100　　　　　　                             Lock(A) //获得S锁   ⑦时刻　　　　　　　 　　　　                                R(A) = 100<br> 　　　　　　　　　　　　　　                                 Unlock(A)

　　

 这样就解决了读脏数据的问题。

 

4.数据库三级封锁协议

协议规则如下：

在读数据的时候，对于请求加S锁，直到事务结束，才释放S锁，而不是读完立即释放

首先，我们来看一下，“不可重复读”的情况，我们假设T1事务的任务就是读2次数据，且隔5s，只是个假设，意思就是没有读完2次A就不算T1事务结束

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

T1                             T2             　　　　   Lock（A）//请求S锁   ①时刻     R(A) = 100   　　　 　  Unlock（A）   ②时刻　  　　　　　                              Lock（A）//对A进行修改   ③时刻                                          R（A）= 100 ， A = 100 - 10  ，W（A）= 90     ④时刻　　　　　　　　　　                         Unlock（A）   ⑤时刻     Lock（A）   ⑥时刻　   R（A）= 90   ⑦时刻　   Unlock（A）

　　

这时候A两次读的数据不一致，出现了不可重复读的情况。

 

根据数据库三级封锁协议，协议的规则，修改如下

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

T1                     T2             　　　　   Lock（A）//请求S锁   ①时刻     R(A) = 100   ②时刻　  　　　　　                    等待     //请求对A进行修改（加了S锁，就不能再加X锁）   ③时刻                                等待    ④时刻　　 R（A）= 100　　　　　         等待              ⑤时刻    Unlock（A）　　　　　　　　    等待   ⑥时刻　　　　　　　　　　　　　　　　Lock（A）获得A数据锁   ⑦时刻　　　 　　　　　　　　　　　　R（A）= 100 ， A = 100 - 10  ，W（A）= 90   　　　　　   ⑧时刻　　　　　　　　　　　　　　　　Unlock（A）

　这就解决了不可重复读问题，以上就是对数据库三级协议的解释。