热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

mysql中删除同一行会经常出现死锁?太可怕了

之前有一个同事问到我,为什么多个线程同时去做删除同一行数据的操作,老是报死锁,在线上已经出现好多次了,我问了他几个问题:1.是不是在一个事务中做了好几件事情?
之前有一个同事问到我,为什么多个线程同时去做删除同一行数据的操作,老是报死锁,在线上已经出现好多次了,我问了他几个问题:
 
1. 是不是在一个事务中做了好几件事情?
     答:不是,只做一个删除操作,自动提交
2. 有多少个线程在做删除?
     答:差不多10个
3. 是什么隔离级别?
     答:可重复读
 
当时觉得不可思议,按说自动提交的话行锁,如果已经有事务加锁了,则会等待,等提交之后再去做,发现已经删除了,就会返回,删除0条,为什么会死锁?
但事情已经出了,必须研究一下,不然终究是心头之苦啊。
然后想到既然线上有这么简单的操作就可以死锁,那么应该写个简单的程序就可以重现,然后同事李润杰兄弟咔嚓咔嚓没多时就给我了,在这里谢谢他。
 
首先环境是这样的:

CREATE TABLE `abcdefg` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `abc` varchar(30),
  `def` varchar(30) ,
  `ghi` date,
  `jkl` date,
  `mnp` tinyint(4),
  PRIMARY KEY (`id`),
  UNIQUE KEY `uniqdefghijkl` (`def`,`ghi`,`jkl`)
);
 
这个表包括2个索引,一个是聚簇索引,另一个是uniqdefghijkl的二级唯一索引。
事先插入很多数据,然后3个线程同时做对同一条记录的删除,这里只做删除操作,并且都是自动提交,为了得到一批要删除的数据,事先查询很多条出来备用。
 
删除语句是这样的:
delete from abcdefg WHERE abc= '我是变量' and def= '我是变量' and ghi= '2013-12-19 00:00:00' and jkl= '2013-12-20 00:00:00';

那么现在就开始重现。。。
果然很快,死锁真的出现了,下面是执行show engine innodb status的结果:
===================================================
LATEST DETECTED DEADLOCK
------------------------
140123 12:20:50
*** (1) TRANSACTION:
TRANSACTION 2E10, ACTIVE 4917 sec starting index read
mysql tables in use 1, locked 1
LOCK WAIT 2 lock struct(s), heap size 376, 1 row lock(s)
MySQL thread id 3, OS thread handle 0x1008, query id 43 192.168.xx.x username upd
ating
delete from abcdefg WHERE abc= '我是变量' and def= '我是变量' and ghi= '2013-12-19 00:00:00' and jkl= '2013-12-20 00:00:00';
*** (1) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 0 page no 12295 n bits 528 index `uniqdefghijkl` of table
`deadlock`.`abcdefg` trx id 2E10 lock_mode X locks rec but not gap waiti
ng
Record lock, heap no 167 PHYSICAL RECORD: n_fields 4; compact format; 

*** (2) TRANSACTION:
TRANSACTION 2E0E, ACTIVE 4917 sec starting index read
mysql tables in use 1, locked 1
3 lock struct(s), heap size 1248, 2 row lock(s)
MySQL thread id 1, OS thread handle 0x1190, query id 41 192.168.xx.xx username upd
ating
delete from abcdefg WHERE abc= '我是变量' and def= '我是变量' and ghi= '2013-12-19 00:00:00' and jkl= '2013-12-20 00:00:00';
*** (2) HOLDS THE LOCK(S):
RECORD LOCKS space id 0 page no 12295 n bits 528 index `uniqdefghijkl` of table
`deadlock`.`abcdefg` trx id 2E0E lock_mode X locks rec but not gap
Record lock, heap no 167 PHYSICAL RECORD: n_fields 4; compact format; 

*** (2) WAITING FOR THIS LOCK TO BE GRANTED:
RECORD LOCKS space id 0 page no 12295 n bits 528 index `uniqdefghijkl` of table
`deadlock`.`abcdefg` trx id 2E0E lock_mode X waiting
Record lock, heap no 167 PHYSICAL RECORD: n_fields 4; compact format; 
*** WE ROLL BACK TRANSACTION (1)
===================================================
这是在三个线程的情况下是可以重现死锁的,但是为了更容易调试,试了一下在2个线程的情况下如何,最终发现重现不了。
这下坏了,多线程调试很麻烦,有时候这个走那个不走的,如果冻结某个线程,有可能导致线程之间死锁,或者自然执行,那又不能出现死锁的情况,因为这个死锁也是偶然性的,所以最终只有一种方法,那就是在mysql代码中打印log信息,将锁、记录与事务这块的函数中具有分歧点的地方都加了注释,并且将有用的信息打印出来,最终分析log文件,才发现了真正死锁的猫腻。
 
现在将三个导致死锁的事务的时序图画出来:
事务A 事务B 事务C
开始    
表的IX锁 17    @1    
二级索引行锁X REC NOTGAP 1059    @2
检查死锁 没事
   
  表IX锁 17    @3  
  二级索引记录行锁 REC NOTGAP X WAIT 1315    @4
检查死锁,没事
 
    表IX锁 17    @5
   
二级索引记录行锁 REC NOTGAP X WAIT 1315    @6
检查死锁 没事
聚簇索引行锁X REC NOTGAP 1059    @7    
  wait.... suspend.... wait.... suspend....
commit    
  wakeup this trx
将@4的WAIT去掉,成为1059
 
 
二级索引记录行锁 REC X WAIT 291    @8
检查死锁 发现死锁
 
图1
 
说明:
上面的数字都是源代码中的关于各种锁的位图值:
LOCK_TABLE:16
LOCK_IX:1
LOCK_REC_NOT_GAP:1024
LOCK_WAIT:256
LOCK_REC:32
LOCK_X:3
 
所以锁@6表示的是 LOCK_REC |  LOCK_REC_NOT_GAP |  LOCK_X |  LOCK_WAIT = 1315
依次类推
 
这里检查死锁的算法大体上说一下,无非是检查有没有形成等待环
事务B的锁@8等待事务C的锁@6,事务C的锁@6在等待事务B的锁@3,此时发现又绕回来了,那么产生死锁。
 
到这里,死锁的现象如何产生已经解释清楚,但是,这是为什么呢?
这里的疑问是:
 
在事务A提交之后,将事务B唤醒了,此时事务B的锁@4为REC NOTGAP X(1059),那么此时这个事务又去检查锁的情况,看看自己事务的锁有没有GRANT成功的,如果有则直接使用并且继续执行,如果没有则再加锁,做这个检查的函数为lock_rec_has_expl,它做的事情是下面的检查:
===========================================================
                lock = lock_rec_get_first(block, heap_no);
                 while (lock) {
                                 if  (lock->trx == trx
                                    && !lock_is_wait_not_by_other(lock->type_mode)
                                    && lock_mode_stronger_or_eq(lock_get_mode(lock),
                                                                                                precise_mode & LOCK_MODE_MASK)
                                    && (!lock_rec_get_rec_not_gap(lock)
                                                || (precise_mode & LOCK_REC_NOT_GAP)
                                                || heap_no == PAGE_HEAP_NO_SUPREMUM)
                                    && (!lock_rec_get_gap(lock)
                                                || (precise_mode & LOCK_GAP)
                                                || heap_no == PAGE_HEAP_NO_SUPREMUM)
                                    && (!lock_rec_get_insert_intention(lock))) {
 
                                                 return(lock);
                                }
 
                                lock = lock_rec_get_next(heap_no, lock);
                }
=============================================================
这里需要满足6个条件:
  1. 首先这个锁是自己事务的
  2. 这个锁不是处于等待状态
  3. 当前锁的类型与precise_mode是兼容的,precise_mode值是X锁,因为这里是要做删除
  4. 当前锁不是NOT GAP类型,或者要加的锁类型是NOTGAP类型的,或者heapno为1
  5. 当前锁不是GAP类型,或者要加的锁类型是GAP类型的,或者heapno为1
  6. 当前锁不是意向插入锁
但此时发现1059(锁@4)根本不满足第4点啊,因为它首先是NOTGAP锁,同时heapno不是1,所以没有找到,所以在外面又重新创建一个锁,因为此时这行已经有锁了,那么它会创建一个REC WAIT X锁(291),也就是锁@8。
 
所以即使锁@4不是处于等待状态了,此时也不能直接执行呢,而是重新创建了一个锁。此时导致了死锁。
 
那么现在问题又来了,从上图可以看到,这个时间序列没有什么特别的,或者特殊的一个交叉过程,从而是不是我们可以很容易的重现呢?仅仅通过开启三个会话,都设置为not autocommit的,因为需要将第一个事务A的提交放在事务B C的后面。
那么开始了,创建相同的表,删除同一行记录。
事务A 事务B 事务C
begin    
delete
删除行数返回为1
   
  begin  
  delete 阻塞  
    begin
    阻塞
commit    
  观察有没有死锁
其实并没有死锁
删除行数返回为0
 
    删除行数返回为0
  图2
 
按说,上面这个图与图1没有什么区别,但没有死锁?为什么?
其实没有死锁是正常的,如果这样就死锁了,那mysql简直不能用了!!!
 
看来还是有区别的
正常模式下再做一次log分析,从log中看出了大问题......
再将上面详细的加锁图在无死锁模式下的情况贴出来:
 
事务A 事务B 事务C
开始    
表的IX锁 17    @1    
二级索引行锁X REC NOTGAP 1059    @2
检查死锁 没事
   
聚簇索引行锁X REC NOTGAP 1059    @7
检查死锁 没事
   
  表IX锁 17    @3  
  二级索引记录行锁 REC X WAIT 291    @4
检查死锁,没事
 
    表IX锁 17    @5
   
二级索引记录行锁 REC X WAIT  291 @6
检查死锁 没事
  wait.... suspend.... wait.... suspend....
commit    
  wakeup this trx
将@4的WAIT去掉,成为35
 
  执行完成,提交  
    执行完成
图3
 
此时发现,图3其实与图1是一样的,那为什么图3可以正常执行完成,而图1死锁了呢?
但认真仔细看了之后,发现有很小的地方是不同的,图3中的锁@4加上的锁是291(REC & X & WAIT),而图1中加的锁比它多了一个NOTGAP的锁,锁@6也是一样的,图3的事务A在提交并且唤醒了锁@4之后,它的锁类型为REC+X(35),而图1中的值也是比它多了一个NOTGAP锁。
 
现在已经基本定位了问题所在,应该是NOTGAP搞的鬼。但是为什么会有差别呢?
此时还需要回到代码中查看,通过日志分析,发现2个在执行下面代码时走了不同的路:
=======================================
                 if (prebuilt->select_lock_type != LOCK_NONE) {
                                ulint        lock_type;
 
                                 if (!set_also_gap_locks
                                    || srv_locks_unsafe_for_binlog
                                    || trx->isolation_level <= TRX_ISO_READ_COMMITTED
                                    || (unique_search
                                                && !UNIV_UNLIKELY(rec_get_deleted_flag(rec, comp)))) {
                                                  goto  no_gap_lock;//直接路到下面  lock_typ e = LOCK_REC_NOT_GAP;处
                                } else {
                                                lock_type = LOCK_ORDINARY;
                                }
                                 if (index == clust_index
                                    && mode == PAGE_CUR_GE
                                    && direction == 0
                                    && dtuple_get_n_fields_cmp(search_tuple)
                                    == dict_index_get_n_unique(index)
                                    && 0 == cmp_dtuple_rec(search_tuple, rec, offsets)) {
no_gap_lock://标记
                                                lock_type = LOCK_REC_NOT_GAP;
                                }
  =======================================  
这里关键的分叉口就是在上面红色字体部分,死锁的时候走了 goto  no_gap_lock,而没有出现死锁的时候走的是 lock_type = LOCK_ORDINARY;,而   LOCK_ORDINARY表示的是0,什么都没有,所以这2条路的不同就是差1024(NOTGAP锁)。
那么从日志中发现,走了第一条路是因为条件 (unique_search  && !UNIV_UNLIKELY(rec_get_deleted_flag(rec, comp))是符合的。 rec_get_deleted_flag函数的作用是判断这条记录是不是已经打了删除标志。
 
现在豁然明白了,如果当前这条要加锁的记录还没有打删除标志,则加的锁是NOTGAP类型的锁,否则就不设置类型,那说明上面的图1中事务A还是有一个细节没有画出来,正因为这个细节与事务B发生了交叉,导致了事务B在做的时候还没有打了删除标记,所以就加了NOTGAP锁,所以导致后面的死锁。
而正常情况下,也就是图2的测试,因为事务A已经完成了所有的操作,只等待提交,此时肯定已经打了删除标志,则在加锁时不会加NOTGAP锁,所以就不会出现死锁。
 
哎,用一句同事常说的话:我这下真的了然了,原来问题这么复杂,mysql中的猫腻太多了。
 
那现在分析一下原因吧:
现在已经确定问题就是出现在上面代码的判断中,在上面代码的上面还有一段注释:
 
                                  /* Try to place a lock on the index record; note that delete
                                marked records are a special case in a unique search. If there
                                is a non-delete marked record, then it is enough to lock its
                                existence with LOCK_REC_NOT_GAP. */
 
这说明了加NOTGAP锁的意图,说明上面代码的判断是专门做的,具体原因就无从查起了,但是注释中说这是一种特殊情况,为什么呢?解决方式是把那2行直接去掉就可以了(测试过不会出现死锁了),但这个会不会是解决问题的根本原因,还要等待官方人员的处理。
 
所以到这里,把完整的死锁图贴上来:
 

事务A 事务B 事务C
开始    
表的IX锁 17    @1    
二级索引行锁X REC NOTGAP 1059    @2
检查死锁 没事
   
  表IX锁 17    @3  
  二级索引记录行锁 REC NOTGAP X WAIT 1315    @4
检查死锁,没事
 
    表IX锁 17    @5
   
二级索引记录行锁 REC NOTGAP X WAIT 1315    @6
检查死锁 没事

对二级索引记录加删除标志(这个是最关键的)
因为这个事件必须要与事务B有交叉点

这个交叉点就是:在锁@2与@7之间,有事务B加了锁@4,事务加了锁@6

   
聚簇索引行锁X REC NOTGAP 1059    @7    
  wait.... suspend.... wait.... suspend....
commit    
  wakeup this trx
将@4的WAIT去掉,成为1059
 
 
二级索引记录行锁 REC X WAIT 291    @8
检查死锁 发现死锁
 
 

思维发散:
1. 对于已经删除的记录(已经提交,但还没有purge),如果再去做删除操作,则此时还会加锁么?加什么锁?(这个问题,由于时间太紧,后面再给出验证说明,如果有兴趣,自己也可以做一下的)
2. 这个问题是在隔离级别是可重复读的情况下存在的,但如果是其它情况下会出现么?
3. 如果是根据主键删除,这个问题还会出现么?
 
总结:在mysql中,其实很多东西都不能按照常理来想的,这个问题本来在达梦与oracle中是根本不可想象的,根本不会出现的,所以才有一开始觉得不可能的感觉,最后才发现,原来是真的。
 
在这里感谢一下同事们的帮助与讨论,感谢勇哥,杰哥

推荐阅读
author-avatar
萝莉控穿大鞋的胖胖
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有