欢迎您访问 最编程 本站为您分享编程语言代码,编程技术文章!
您现在的位置是: 首页

数据库三级拦截协议简介

最编程 2024-07-05 16:48:13
...

 

免费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锁释放。

 

                   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 加锁,则如下面:

                    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
Unlock(A)

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

 

4.数据库三级*协议

协议规则如下:

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

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

                   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两次读的数据不一致,出现了不可重复读的情况。

 

根据数据库三级*协议,协议的规则,修改如下

 

                  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)

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