MySQL - 排它锁 for update 及 共享锁 sel

排它锁(写锁) For Update

---

作用

使用for update 为所有查询select的记录加上独占锁。

独占锁又叫写锁，意思在锁的期间，不允许其他任何尝试获取锁(包括读锁和写锁)的请求，只有这个锁被释放掉才能被另外一个事务获取锁。

示例

事务 T1 先执行如下语句

begin;
select * from trans where id=2 for update; -- 这里对id=2的记录进行加锁(排它锁)
-- 注意这里还没有结束事务,会一直占用着id=2记录的锁

事务 T2 在以上语句执行后 执行如下语句:

begin;   -- 即使没有开始事务,下面的语句也会被一直阻塞
select * from trans; -- 这里只是简单请求查询，并没有请求获取锁，所以这里不会被阻塞，不需要等待事务T1结束事务



select * from trans for update; -- 这里查询包含id=2的记录，尝试获取排它锁，但由于事务T1还没有结束事务，一直占用着id=2的行锁，所以这里会一直等待获取锁

update trans set xxx=xxx where id=2; -- update语句也会尝试申请写锁，所以这里也一样被阻塞，等待事务T1的锁

commit; 

应用场景

使用for update 可以解决脏读问题,例如:
有两个定时任务（可以当作两个事务）分别为Job-1 和 Job-2, 这两个Job都会修改同一条记录，可能出现其中一个Job 读取这条记录，是另外一个Job准备要修改的，等另外一个Job修改完，这个Job读取的这条记录已经过时，如下执行顺序(就当下面是44拍乐谱里的一小节):

          ①                              ④
Job-1: | ======= | ======= | ======= | ======= |



                    ②         ③
Job-2: | ======= | ======= | ======= | ======= |

注解:
顺序① : 执行查询语句，准备下一步更新

 -- Job-1语句
begin;
select total from xxx where id=2; -- 这里查询id=2记录的total,得出total值为3

顺序②: Job-2 更新Job-1 在顺序-1中查询的记录

 -- Job-2语句
begin;
update xxx set total=10 where id=2; -- 这里修改id=2记录的total值为10

顺序③: Job-2 结束事务

 -- Job-2语句
commit;

顺序④: 使用过期数据total进行累加递增

 -- Job-1语句
update xxx set total=3+10 where id=2; -- 由于这里的3已经过时了，导致total与实际的10相差了7,实际累计之后应该是 10 + 10 = 20
commit;

解决

为了解决Job-1读取的id=2记录的total值不过时，所以在顺序①查询id=2时通过for update 进行加锁即可：

-- Job-1语句
select * from trans where id=2 for update;

或者使用共享锁:

select * from trans where id=2 lock in share mode;

关于共享锁请往下看。

.
.
.
.
.
.
.
.

共享锁(读锁) Select ... lock in share mode

---

作用

对select 查询的所有记录加上共享锁(或者说获取这些记录的共享锁)
允许其他事务也加上共享锁
但不允许其他事务加上写锁

共享锁的特征

1. 别名
   共享锁又读锁

2. 何谓"共享"?
   所谓共享的意思是如果事务 A 获取了共享锁, 允许事务B 也获取共享锁，即允许事务B 可以读取相同的数据，就是这样, 对另外一个获取“共享锁”的事务共享当前正在读的数据。

   但对写锁却是“排它”的，意思在获取的读锁的时候不允许写锁进行写数据，要不然就会出现脏读（读到的数据因为被更改而过时）。

3. 实现原理:
   有一个先进先出的队列,队列中存放的都是所有锁，包括共享锁 和 排它锁。如下FIFO队列示意图, 按照从左到右的先进先出顺序存放各种锁：

列头 < ①Read Lock == ②Read Lock < ③Write Lock < ④Read Lock < 列尾

注意：上图队列中 读锁① 和 读锁② 中间用等号，表示这两个锁可以同时进行数据查询。其余的小于符号表示 右边的锁等待小于符号左边的锁。

上图队列中一共有4个锁，分别为读锁①、读锁②、写锁③、读锁④。并且每个锁都分别对用有1个事务进行获取，即有4个事务。

事务1(读锁)
select * from trans where id=2 lock in share mode;

事务2(读锁)
select * from trans where id=2 lock in share mode;

事务3(写锁)
update trans set xxx=10 where id=2; -- 加上写锁（独占锁）
或
select * from trans where id=2 for update; -- 加上独占锁。

事务4(读锁)
select * from trans where id=2 lock in share mode;

请求锁顺序:

1. 事务获得①读锁。
2. 事务2尝试获取读锁②，发现前面已经有①锁并且是一个读锁，这时候获取成功,并可以读取到共享锁正在读取的数据。
3. 事务3尝试用获取写锁③，但发现前面已经有两个写锁，所以等待直至读锁释放掉。
4. 事务4常使用获取 读锁④，发现前面的是写锁③，所以等待事务3释放写锁③,而写锁③正在等待前面两个 读锁①、读锁②，所以事务4间接在等待 最前面两个读锁。

参考

---

可以参考 Zookeeper 中的共享锁及独占锁，原理基本上跟上面说的一样。