精华内容
下载资源
问答
  • 表锁和行锁
    千次阅读
    2021-11-23 14:21:33

    表读锁 lock table read; 一个session设置读锁,当前session更新和插入都会报错,另一个session只能读,写会阻塞。

    表写锁 lock table write; 一个session设置写锁,当前session可以增删改查都可以,另一个session不能读写都会阻塞,直到锁被释放。  unlock tables;

    行共享锁: select * from 表名 where id = 1 lock in share mode; 当一个session设置共享锁,另一个session也可以设置共享锁成功。查询操作不影响,当第一个session进行更新操作会阻塞,第二个session进行更新操作时会因为发生死锁而退出,此时第一个session设置成功。第一个session可以读写,第二个session也可以读,但是写操作直到第一个session commit之后才能进行操作。

    行排他锁  select * from 表名 where id = 1 for update; 当一个session设置排他锁,另一个session在设置锁时会阻塞,第一个session可以读写,第二个session也可以读,但是写操作直到第一个session commit之后才能进行操作。

    注:1、mysql 会把 update insert delete 操作 隐式添加for update;

           2、mysql 加行锁时,如果改sql没有用到索引,那它会将转换成表锁。行锁并不是争对记录,而是对索引。

    mysql 记录锁 间隙锁 临键锁

    记录锁 select * from student where id=1 for update;//锁住一行,通过主键索引和唯一索引实现。

    1、查询命中索引

    事务1
    
    begin;
    UPDATE book SET score = 9.2 WHERE ID = 16;
    
    事务2
    
    begin;
    UPDATE book SET score = 9.2 WHERE ID = 10;#阻塞
    
    delete from book WHERE ID = 10;#阻塞

    2、查询未命中索引

    事务1
    begin;
    UPDATE book SET score = 9.2 WHERE id = 12;
    
    事务2
    begin;
    UPDATE book SET score = 9.2 WHERE ID = 12;#不会对更新阻塞
    
    delete from book WHERE ID = 12;#不会对删除阻塞
    
    insert into book(id,isbn,author,score)  values(17,'N0008','lisi',1); #对插入区间的数据阻塞(10,18)

     3、二级唯一索引,查询命中

    事务1
    begin;
    UPDATE book SET score = 9.2 WHERE ISBN = 'N0003'
    
    事务2
    begin;
    UPDATE book SET score = 9.2 WHERE ISBN = 'N0003';#更新阻塞
    
    delete from book WHERE ISBN = 'N0003';#删除阻塞
    
    insert into book(id,isbn,author,score)  values(17,'N00003','lisi',1); #插入阻塞

    4、二级唯一索引,查询未命中

    事务1
    begin;
    UPDATE book SET score = 9.2 WHERE ISBN = 'N0000'
    
    
    事务2
    begin;
    UPDATE book SET score = 9.2 WHERE ISBN = 'N0000';#更新不阻塞
    
    delete from book WHERE ISBN = 'N0000';#删除不阻塞
    
    insert into book(id,isbn,author,score)  values(9,'N0000','lisi',1); 
    #插入阻塞(负无穷大,N0000) 因为N0000不存在而且在最左侧
    
    例2
    begin;
    UPDATE book SET score = 9.2 WHERE ISBN = 'N0008'
    
    begin;
    UPDATE book SET score = 9.2 WHERE ISBN = 'N0008';#更新不阻塞
    
    delete from book WHERE ISBN = 'N0008';#删除不阻塞
    
    insert into book(id,isbn,author,score)  values(9,'N0008','lisi',1); 
    #插入阻塞(N0008,无穷大) 因为N0008不存在而且在最右侧
    

    5、二级索引 查询命中

    1、事务1
    START transaction ;
    UPDATE book SET score = 9.2 WHERE Author = 'Tom'
    
    
    2、事务2
    START transaction ;
    UPDATE book SET score = 9.2 WHERE author = 'Tom';#更新阻塞
    
    START transaction ;
    UPDATE book SET score = 9.2 WHERE author = 'ton';#更新不阻塞
    
    START transaction ;
    delete from book WHERE author = 'Tom';#删除阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Rosd',1); #不阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Rosf',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','ton',1); #插入阻塞
    
    总结
    对author排序后
    18	N0002	Alice	7.7
    10	N0001	Bob	    3.4
    30	N0004	Eric	9.1
    25	N0003	Jim	    5
    60	N0007	Rose	8.9
    41	N0005	Tom	    2.2
    49	N0006	Tom	    8.3
    锁定区间(rose,tom) (tom) (tom,无穷大)
    
    
    

    6、二级索引 查询未命中

    1、事务1
    START transaction ;
    UPDATE book SET score = 9.2 WHERE Author = 'Sarah'
    
    2、事务2
    
    START transaction ;
    UPDATE book SET score = 9.2 WHERE author = 'Sarah';#更新不阻塞
    
    START transaction ;
    delete from book WHERE author = 'Sarah';#删除不阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Rosd',1); #不阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Rosf',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Sarah',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Rose',1); #不阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Tol',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Tom',1); #不阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(48,'N0000','Ton',1); #不阻塞
    总结
    对author排序后
    18	N0002	Alice	7.7
    10	N0001	Bob	    3.4
    30	N0004	Eric	9.1
    25	N0003	Jim	    5
    60	N0007	Rose	8.9
    41	N0005	Tom	    2.2
    49	N0006	Tom	    8.3
    锁定区间(rose,tom)

    7、主键索引 范围

    1、事务1
    START transaction ;
    UPDATE book SET score = 9.2 WHERE ID <= 25;
    2、事务2
    
    START transaction ;
    UPDATE book SET score = 9.2 WHERE id = 1;#更新不阻塞
    START transaction ;
    UPDATE book SET score = 9.2 WHERE id = 10;#更新阻塞
    
    START transaction ;
    UPDATE book SET score = 9.2 WHERE id = 18;#更新阻塞
    
    START transaction ;
    UPDATE book SET score = 9.2 WHERE id = 12;#更新不阻塞
    
    START transaction ;
    UPDATE book SET score = 9.2 WHERE id = 25;#更新阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(1,'N0000','Rosd',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(11,'N0000','Rosf',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(26,'N0000','Sarah',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(30,'N0000','Rose',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(31,'N0000','Tol',1); #不阻塞
    总结
    对id排序后
    10	N0001	Bob	    3.4
    18	N0002	Alice	7.7
    25	N0003	Jim	    5
    30	N0004	Eric	9.1
    41	N0005	Tom	    2.2
    49	N0006	Tom	    8.3
    60	N0007	Rose	8.9
    锁定区间(负无穷,10] (10,25] (25,30] 
    
    【2】、主键范围未命中
    事务1
    START transaction ;
    UPDATE book SET score = 1.1 WHERE id <=12; 
    事务2、(分析where id = 12 (间隙锁(10,18)),<12 主键范围未命中加锁(负无穷大,10](10,18]))
    合并即为,(负无穷大,10](10,18]
    
    【3】、多个主键取范围
    START transaction ;
    UPDATE book SET score = 1.1 WHERE id >=10 and id <12; 
    
    事务1
    START transaction ;
    UPDATE book SET score = 1.1 WHERE id >=10 and id <12; 
    事务2
    id >=10 锁住区间 [10,无穷大]
    id < 12 (负无穷大,10](10,18] 
    取交集 锁住[10,18]
    
    

    8、二级索引 范围

    【1】未命中
    1、事务1
    
    START transaction ;
    UPDATE book SET author = 'N00001' WHERE score <= 7.9
    
    2、事务2
    
    START transaction ;
    UPDATE book SET author = '1' WHERE score = 1;#更新不阻塞
    START transaction ;
    UPDATE book SET author = '1' WHERE score = 2.2;#更新阻塞
    
    START transaction ;
    UPDATE book SET author = '1' WHERE score = 7.9;#更新不阻塞
    
    START transaction ;
    UPDATE book SET author = '1' WHERE score = 8.3;#更新阻塞
    
    START transaction ;
    UPDATE book SET author = '1' WHERE score = 9.1;#更新阻塞
    
    所有插入都会阻塞
    START transaction ;
    insert into book(id,isbn,author,score)  values(1,'N0000','Rosd',1); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(11,'N0000','Rosf',2.2); #阻塞
    
    START transaction ;
    insert into book(id,isbn,author,score)  values(26,'N00010','Sarah',18.4); #阻塞
    总结
    对score 排序后
    41	N0005	Tom	    2.2
    10	N0001	Bob	    3.4
    25	N0003	Jim	    5
    18	N0002	Alice	7.7
    49	N0006	Tom	    8.3
    60	N0007	Rose	8.9
    30	N0004	Eric	9.1
    todo 猜想和表锁一样...
    
    【2】命中
    事务1
    START transaction ;
    UPDATE book SET author = '1' where score <7.7; 
    
    事务2
    锁住区间
    (负无穷大,7.7]
    
    【3】等值+范围命中
    事务1
    START transaction ;
    UPDATE book SET author = '1' where score <=7.7; 
    
    事务2
    锁住区间
    (负无穷大,正无穷大] 相当于表锁?
    【4】两个范围条件
    事务1
    START transaction ;
    UPDATE book SET author = '1' where score > 2.2 and score <7.7; 
    事务2
    锁住区间 score > 2.2 (2.2,正无穷大)
            score <7.7 (负无穷大,7.7]
    合并之后:(2.2,7.7]
    

    9、组合索引 

    1、事务1
    
    start TRANSACTION;
    
    select * from book where author = 'Tom' and score = 8.3 for update;
    
    2、事务2
    start TRANSACTION;
    
    select * from book where author = 'Bob' for update;#不阻塞
    
    start TRANSACTION;
    select * from book where author = 'Tom' for update; #阻塞
    
    
    start TRANSACTION;
    select * from book where score = 7.7 for update;#不阻塞
    
    start TRANSACTION;
    select * from book where score = 8.3 for update;#阻塞
    
    
    总结
    对score 排序后
    41	N0005	Tom	    2.2
    10	N0001	Bob	    3.4
    25	N0003	Jim	    5
    18	N0002	Alice	7.7
    49	N0006	Tom	    8.3
    60	N0007	Rose	8.9
    30	N0004	Eric	9.1
    todo 猜想只是相当于行锁
    
    
    
    

    更多相关内容
  • MySQL表锁和行锁演示

    2021-10-16 10:07:22
    MySQL中表锁和行锁及其演示一、表锁1、表锁的特点:2、案例分析:1)读锁演示2)写锁演示3、总结:二、行锁1、特点:2、案例分析:3、行锁分析:4、总结:三、页锁四、全局锁 Mysql中的锁按锁粒度从大到小分类:表锁...

    Mysql中的锁按锁粒度从大到小分类:表锁,页锁和行锁;以及特殊场景下使用的全局锁,重点掌握表锁和行锁就可以了,今天我们就来简单聊聊这几种锁。
    在这里插入图片描述

    一、表锁

    1、表锁的特点:

    偏向MyISAM存储引擎,开销小,加锁快;无死锁;锁定粒度大,发生锁冲突的概率最高,并发度最低。


    2、案例分析:

    1)读锁演示

    1、建表:

    create table mylock(
     id int not null primary key auto_increment,
     name varchar(20)
    )engine myisam;
     
    insert into mylock(name) values('a');
    insert into mylock(name) values('b');
    insert into mylock(name) values('c');
    insert into mylock(name) values('d');
    insert into mylock(name) values('e');
     
    select * from mylock;
    
    

    2、新建两个session窗口:session_1、session_2;

    3、在session_1窗口中给mylock表添加读锁:

    (注意:read锁可以被添加多个,比方说:此时还可以用相同的命令给session_2添加mylock表的读锁,此时上图中的In_user就变成了2)

    4、使用session_1对其它表进行读操作:

    操作失败,必须先释放mylock表的读锁,主要是为了避免死锁。

    5、使用session_2对其它表进行读操作:

    6、使用session_1对mylock表进行读、写操作:

    7、使用session_2对mylock表进行读、写操作:

    8、session_1释放mylock表的读锁:

    此时,被阻塞的session_2窗口将修改成功:

    2)写锁演示

    1、session_1给mylock表添加写锁:

    2、session_1对mylock表进行读、写操作:

    3、session_2对mylock表进行读操作:

    (读都被阻塞的话,就更不用说写了)


    注意:如果持有表锁的session异常终止的话(比如说执行了“ctrl+z”),那么该session是不会主动释放锁的,这时候我们可以重启mysql服务器,但这不是一个值得的办法,其实我们可以在任意一个session会话中通过show processlist命令来查看线程Id,再通过kill 【线程Id】来关闭对应的会话。

    3、总结:

    MyISAM在执行查询语句(SELECT)前,会自动给涉及的所有表加读锁,在执行增删改操作前,会自动给涉及的表加写锁。
    MySQL的表级锁有两种模式:
    表共享读锁(Table Read Lock)
    表独占写锁(Table Write Lock)

    结论:
    结合上表,所以对MyISAM表进行操作,会有以下情况:
    1、对MyISAM表的读操作(加读锁),不会阻塞其他进程对同一表的读请求,但会阻塞对同一表的写请求。只有当读锁释放后,才会执行其它进程的写操作。
    2、对MyISAM表的写操作(加写锁),会阻塞其他进程对同一表的读和写操作,只有当写锁释放后,才会执行其它进程的读写操作。
    简而言之,就是读锁会阻塞写,但是不会堵塞读。而写锁则会把读和写都堵塞。


    二、行锁

    1、特点:

    偏向InnoDB存储引擎,开销大,加锁慢;会出现死锁;锁定粒度最小,发生锁冲突的概率最低,并发度也最高。


    2、案例分析:

    1. 建表建检索:
    create table mylock2 (a int(11),b varchar(16))engine=innodb;
    
    insert into mylock2 values(1,'b2');
    insert into mylock2 values(3,'3');
    insert into mylock2 values(4,'4000');
    insert into mylock2 values(5,'5000');
    insert into mylock2 values(6,'6000');
    insert into mylock2 values(7,'7000');
    insert into mylock2 values(8,'8000');
    insert into mylock2 values(9,'9000');
    insert into mylock2 values(1,'b1');
    
    create index test_innodb_a_ind on mylock2(a);
    
    create index test_innodb_lock_b_ind on mylock2(b);
    
    select * from mylock2;
    ## 结果:
    ## +------+------+
    ## | a    | b    |
    ## +------+------+
    ## |    1 | b2   |
    ## |    3 | 3    |
    ## |    4 | 4000 |
    ## |    5 | 5000 |
    ## |    6 | 6000 |
    ## |    7 | 7000 |
    ## |    8 | 8000 |
    ## |    9 | 9000 |
    ## |    1 | b1   |
    ## +------+------+
    ## 9 rows in set (0.00 sec)
    

    为什么这里需要创建索引?
    这里我们就需要知道InnoDB引擎行锁的特性了:

    1. 在不通过索引条件查询的时候,InnoDB使用的确实是表锁!
    2. 由于 MySQL 的行锁是针对索引加的锁,不是针对记录加的锁,所以虽然是访问不同行的记录,但是如果是使用相同的索引键,是会出现锁冲突的。
    3. 当表有多个索引的时候,不同的事务可以使用不同的索引锁定不同的行,另外,不论是使用主键索引、唯一索引或普通索引,InnoDB 都会使用行锁来对数据加锁。
    4. 即便在条件中使用了索引字段,但是否使用索引来检索数据是由 MySQL 通过判断不同执行计划的代价来决定的,如果 MySQL 认为全表扫效率更高,比如对一些很小的表,它就不会使用索引,这种情况下 InnoDB 将使用表锁,而不是行锁。因此,在分析锁冲突时,别忘了检查 SQL 的执行计划(explain查看),以确认是否真正使用了索引。
    1. 创建两个session窗口session_1和session_2,并设置不自动提交:set autocommit = 0;

    2. session_1进行一条记录进行写操作(未提交)

    3. session_2对mylock2表进行一些读写操作
      在这里插入图片描述

    4. 无索引或索引失效都会导致行锁升级未表锁:
      在这里插入图片描述
      在这里插入图片描述


    3、行锁分析:

    通过命令:show status like 'innodb_row_lock%';可以来分析系统上的行锁的争夺情况;
    在这里插入图片描述
    尤其是当等待次数很高,而且每次等待时长也不小的时候,我们就需要分析系统中为什么会有如此多的等待,然后根据分析结果着手指定优化计划。
    最后可以通过
    SELECT * FROM information_schema.INNODB_TRX\G;
    来查询正在被锁阻塞的sql语句。
    在这里插入图片描述


    4、总结:

    Innodb存储引擎由于实现了行级锁定,虽然在锁定机制的实现方面所带来的性能损耗可能比表级锁定会要更高一些,但是在整体并发处理能力方面要远远优于MyISAM的表级锁定的。当系统并发量较高的时候,Innodb的整体性能和MyISAM相比就会有比较明显的优势了。

    但是,Innodb的行级锁定同样也有其脆弱的一面,当我们使用不当的时候,可能会让Innodb的整体性能表现不仅不能比MyISAM高,甚至可能会更差。

    三、页锁

    除了表锁、行锁外,MySQL还有一种相对偏中性的页级锁,页锁是MySQL中比较独特的一种锁定级别,在其他数据库管理软件中也并不是太常见。页级锁定的特点是锁定颗粒度介于行级锁定与表级锁之间,所以获取锁定所需要的资源开销,以及所能提供的并发处理能力也同样是介于上面二者之间。另外,页级锁定和行级锁定一样,会发生死锁。

    使用页级锁定的主要是BerkeleyDB存储引擎。

    四、全局锁

    首先全局锁,是对整个数据库实例加锁。使用场景一般在全库逻辑备份时。

    MySQL提供加全局读锁的命令:

    Flush tables with read lock (FTWRL)(客户端发生异常断开,那么MySQL会自动释放这个全局锁)

    set global readonly=true(客户端发生异常断开,数据库依旧会保持readonly状态,会导致整个库长时间处于不可写状态,试想一下微信只能看,不能打字)

    这个命令可以使整个库处于只读状态。使用该命令之后,数据更新语句、数据定义语句和更新类事务的提交语句等修改数据库的操作都会被阻塞。

    风险:

    1. 如果在主库备份,在备份期间不能更新,业务停摆;
    2. 如果在从库备份,备份期间不能执行主库同步的binlog,导致主从延迟同步。

    参考文章:
    面试让HR都能听懂的MySQL锁机制,欢声笑语中搞懂MySQL锁

    展开全文
  • MySQL 表锁和行锁机制 分析

    千次阅读 2021-08-12 16:27:30
    行锁表锁,是福还是坑?如果你不清楚MySQL加锁的原理,你会被它整的很惨!不知坑在何方?没事,我来给你们标记几个坑。遇到了可别乱踩。通过本章内容,带你学习MySQL的行锁表锁,两种锁的优缺点,行锁表锁的...

    Linux服务器开发/后台架构师知识体系整理

    行锁变表锁,是福还是坑?如果你不清楚MySQL加锁的原理,你会被它整的很惨!不知坑在何方?没事,我来给你们标记几个坑。遇到了可别乱踩。通过本章内容,带你学习MySQL的行锁,表锁,两种锁的优缺点,行锁变表锁的原因,以及开发中需要注意的事项。还在等啥?经验等你来拿!

    MySQL的存储引擎是从MyISAM到InnoDB,锁从表锁到行锁。后者的出现从某种程度上是弥补前者的不足。比如:MyISAM不支持事务,InnoDB支持事务。表锁虽然开销小,锁表快,但高并发下性能低。行锁虽然开销大,锁表慢,但高并发下相比之下性能更高。事务和行锁都是在确保数据准确的基础上提高并发的处理能力。本章重点介绍InnoDB的行锁。

    案例分析

    目前,MySQL常用的存储引擎是InnoDB,相对于MyISAM而言。InnoDB更适合高并发场景,同时也支持事务处理。我们通过下面这个案例(坑),来了解行锁和表锁。

    业务:因为订单重复导入,需要用脚本将订单状态为"待客服确认"且平台是"xxx"的数据批量修改为"已关闭"。

    说明:避免直接修改订单表造成数据异常。这里用innodb_lock 表演示InnoDB的行锁。表中有三个字段:id,k(key值),v(value值)。

    步骤:
    第一步:连接数据库,这里为了方便区分命名为Transaction-A,设置autocommit为零,表示需手动提交事务。
    第二步:Transaction-A,执行update修改id为1的命令。
    第三步:新增一个连接,命名为Transaction-B,能正常修改id为2的数据。再执行修改id为1的数据命令时,却发现该命令一直处理阻塞等待中。
    第四步:Transaction-A,执行commit命令。Transaction-B,修改id为1的命令自动执行,等待37.51秒。

    总结:多个事务操作同一行数据时,后来的事务处于阻塞等待状态。这样可以避免了脏读等数据一致性的问题。后来的事务可以操作其他行数据,解决了表锁高并发性能低的问题。

    # Transaction-A
    mysql> set autocommit = 0;
    mysql> update innodb_lock set v='1001' where id=1;
    mysql> commit;
    
    # Transaction-B
    mysql> update innodb_lock set v='2001' where id=2;
    Query OK, 1 row affected (0.37 sec)
    mysql> update innodb_lock set v='1002' where id=1;
    Query OK, 1 row affected (37.51 sec)
    

    有了上面的模拟操作,结果和理论又惊奇的一致,似乎可以放心大胆的实战。但现实真的很残酷。

    现实:当执行批量修改数据脚本的时候,行锁升级为表锁。其他对订单的操作都处于等待中,
    原因:InnoDB只有在通过索引条件检索数据时使用行级锁,否则使用表锁!而模拟操作正是通过id去作为检索条件,而id又是MySQL自动创建的唯一索引,所以才忽略了行锁变表锁的情况。步骤:

    步骤:
    第一步:还原问题,Transaction-A,通过k=1更新v。Transaction-B,通过k=2更新v,命令处于阻塞等待状态。
    第二步:处理问题,给需要作为查询条件的字段添加索引。用完后可以删掉。

    总结:InnoDB的行锁是针对索引加的锁,不是针对记录加的锁。并且该索引不能失效,否则都会从行锁升级为表锁

    Transaction-A
    mysql> update innodb_lock set v='1002' where k=1;
    mysql> commit;
    mysql> create index idx_k on innodb_lock(k);
    
    Transaction-B
    mysql> update innodb_lock set v='2002' where k=2;
    Query OK, 1 row affected (19.82 sec)
    

    从上面的案例看出,行锁变表锁似乎是一个坑,可MySQL没有这么无聊给你挖坑。这是因为MySQL有自己的执行计划。

    当你需要更新一张较大表的大部分甚至全表的数据时。而你又傻乎乎地用索引作为检索条件。一不小心开启了行锁(没毛病啊!保证数据的一致性!)。可MySQL却认为大量对一张表使用行锁,会导致事务执行效率低,从而可能造成其他事务长时间锁等待和更多的锁冲突问题,性能严重下降。所以MySQL会将行锁升级为表锁,即实际上并没有使用索引。

    我们仔细想想也能理解,既然整张表的大部分数据都要更新数据,在一行一行地加锁效率则更低。其实我们可以通过explain命令查看MySQL的执行计划,你会发现key为null。表明MySQL实际上并没有使用索引,行锁升级为表锁也和上面的结论一致。

    行锁

    行锁的劣势:开销大;加锁慢;会出现死锁
    行锁的优势:锁的粒度小,发生锁冲突的概率低;处理并发的能力强
    加锁的方式:自动加锁。对于UPDATE、DELETE和INSERT语句,InnoDB会自动给涉及数据集加排他锁;对于普通SELECT语句,InnoDB不会加任何锁;当然我们也可以显示的加锁:
    共享锁:select * from tableName where … + lock in share more
    排他锁:select * from tableName where … + for update
    InnoDB和MyISAM的最大不同点有两个:一,InnoDB支持事务(transaction);二,默认采用行级锁。加锁可以保证事务的一致性,可谓是有人(锁)的地方,就有江湖(事务);我们先简单了解一下事务知识。

    MySQL 事务属性

    事务是由一组SQL语句组成的逻辑处理单元,事务具有ACID属性。

    原子性(Atomicity):事务是一个原子操作单元。在当时原子是不可分割的最小元素,其对数据的修改,要么全部成功,要么全部都不成功。

    一致性(Consistent):事务开始到结束的时间段内,数据都必须保持一致状态。

    隔离性(Isolation):数据库系统提供一定的隔离机制,保证事务在不受外部并发操作影响的"独立"环境执行。

    持久性(Durable):事务完成后,它对于数据的修改是永久性的,即使出现系统故障也能够保持。

    事务常见问题

    更新丢失(Lost Update)
    原因:当多个事务选择同一行操作,并且都是基于最初选定的值,由于每个事务都不知道其他事务的存在,就会发生更新覆盖的问题。类比github提交冲突。

    脏读(Dirty Reads)
    原因:事务A读取了事务B已经修改但尚未提交的数据。若事务B回滚数据,事务A的数据存在不一致性的问题。

    不可重复读(Non-Repeatable Reads)
    原因:事务A第一次读取最初数据,第二次读取事务B已经提交的修改或删除数据。导致两次读取数据不一致。不符合事务的隔离性。

    幻读(Phantom Reads)
    原因:事务A根据相同条件第二次查询到事务B提交的新增数据,两次数据结果集不一致。不符合事务的隔离性。

    幻读和脏读有点类似
    脏读是事务B里面修改了数据,
    幻读是事务B里面新增了数据。

    事务的隔离级别

    数据库的事务隔离越严格,并发副作用越小,但付出的代价也就越大。这是因为事务隔离实质上是将事务在一定程度上"串行"进行,这显然与"并发"是矛盾的。根据自己的业务逻辑,权衡能接受的最大副作用。从而平衡了"隔离" 和 "并发"的问题。MySQL默认隔离级别是可重复读。脏读,不可重复读,幻读,其实都是数据库读一致性问题,必须由数据库提供一定的事务隔离机制来解决。

    +------------------------------+---------------------+--------------+--------------+--------------+
    | 隔离级别                      | 读数据一致性         | 脏读         | 不可重复 读   | 幻读         |
    +------------------------------+---------------------+--------------+--------------+--------------+
    | 未提交读(Read uncommitted)    | 最低级别            |||| 
    +------------------------------+---------------------+--------------+--------------+--------------+
    | 已提交读(Read committed)      | 语句级              ||||
    +------------------------------+---------------------+--------------+--------------+--------------+
    | 可重复读(Repeatable read)     | 事务级              ||||
    +------------------------------+---------------------+--------------+--------------+--------------+
    | 可序列化(Serializable)        | 最高级别,事务级     ||||
    +------------------------------+---------------------+--------------+--------------+--------------+
    

    查看当前数据库的事务隔离级别:show variables like ‘tx_isolation’;

    mysql> show variables like 'tx_isolation';
    +---------------+-----------------+
    | Variable_name | Value           |
    +---------------+-----------------+
    | tx_isolation  | REPEATABLE-READ |
    +---------------+-----------------+
    

    间隙锁

    当我们用范围条件检索数据,并请求共享或排他锁时,InnoDB会给符合条件的已有数据记录的索引项加锁;对于键值在条件范围内但并不存在的记录,叫做"间隙(GAP)"。InnoDB也会对这个"间隙"加锁,这种锁机制就是所谓的间隙锁(Next-Key锁)。

    Transaction-A
    mysql> update innodb_lock set k=66 where id >=6;
    Query OK, 1 row affected (0.63 sec)
    mysql> commit;
    
    Transaction-B
    mysql> insert into innodb_lock (id,k,v) values(7,'7','7000');
    Query OK, 1 row affected (18.99 sec)
    

    危害(坑):若执行的条件是范围过大,则InnoDB会将整个范围内所有的索引键值全部锁定,很容易对性能造成影响。

    排他锁

    排他锁,也称写锁,独占锁,当前写操作没有完成前,它会阻断其他写锁和读锁。

    在这里插入图片描述

    # Transaction_A
    mysql> set autocommit=0;
    mysql> select * from innodb_lock where id=4 for update;
    +----+------+------+
    | id | k    | v    |
    +----+------+------+
    |  4 | 4    | 4000 |
    +----+------+------+
    1 row in set (0.00 sec)
    
    mysql> update innodb_lock set v='4001' where id=4;
    Query OK, 1 row affected (0.00 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    mysql> commit;
    Query OK, 0 rows affected (0.04 sec)
    
    # Transaction_B
    mysql> select * from innodb_lock where id=4 for update;
    +----+------+------+
    | id | k    | v    |
    +----+------+------+
    |  4 | 4    | 4001 |
    +----+------+------+
    1 row in set (9.53 sec)
    

    共享锁

    共享锁,也称读锁,多用于判断数据是否存在,多个读操作可以同时进行而不会互相影响。当如果事务对读锁进行修改操作,很可能会造成死锁。如下图所示。
    在这里插入图片描述

    # Transaction_A
    mysql> set autocommit=0;
    mysql> select * from innodb_lock where id=4 lock in share mode;
    +----+------+------+
    | id | k    | v    |
    +----+------+------+
    |  4 | 4    | 4001 |
    +----+------+------+
    1 row in set (0.00 sec)
    
    mysql> update innodb_lock set v='4002' where id=4;
    Query OK, 1 row affected (31.29 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    
    # Transaction_B
    mysql> set autocommit=0;
    mysql> select * from innodb_lock where id=4 lock in share mode;
    +----+------+------+
    | id | k    | v    |
    +----+------+------+
    |  4 | 4    | 4001 |
    +----+------+------+
    1 row in set (0.00 sec)
    
    mysql> update innodb_lock set v='4002' where id=4;
    ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction
    

    分析行锁定

    通过检查InnoDB_row_lock 状态变量分析系统上的行锁的争夺情况 show status like ‘innodb_row_lock%’

    mysql> show status like 'innodb_row_lock%';
    +-------------------------------+-------+
    | Variable_name                 | Value |
    +-------------------------------+-------+
    | Innodb_row_lock_current_waits | 0     |
    | Innodb_row_lock_time          | 0     |
    | Innodb_row_lock_time_avg      | 0     |
    | Innodb_row_lock_time_max      | 0     |
    | Innodb_row_lock_waits         | 0     |
    +-------------------------------+-------+
    

    innodb_row_lock_current_waits: 当前正在等待锁定的数量
    innodb_row_lock_time: 从系统启动到现在锁定总时间长度;非常重要的参数,
    innodb_row_lock_time_avg: 每次等待所花平均时间;非常重要的参数,
    innodb_row_lock_time_max: 从系统启动到现在等待最常的一次所花的时间;
    innodb_row_lock_waits: 系统启动后到现在总共等待的次数;非常重要的参数。直接决定优化的方向和策略。

    行锁优化

    1 尽可能让所有数据检索都通过索引来完成,避免无索引行或索引失效导致行锁升级为表锁。
    2 尽可能避免间隙锁带来的性能下降,减少或使用合理的检索范围。
    3 尽可能减少事务的粒度,比如控制事务大小,而从减少锁定资源量和时间长度,从而减少锁的竞争等,提供性能。
    4 尽可能低级别事务隔离,隔离级别越高,并发的处理能力越低。

    表锁

    表锁的优势:开销小;加锁快;无死锁
    表锁的劣势:锁粒度大,发生锁冲突的概率高,并发处理能力低
    加锁的方式:自动加锁。查询操作(SELECT),会自动给涉及的所有表加读锁,更新操作(UPDATE、DELETE、INSERT),会自动给涉及的表加写锁。也可以显示加锁:
    共享读锁:lock table tableName read;
    独占写锁:lock table tableName write;
    批量解锁:unlock tables;

    共享读锁

    对MyISAM表的读操作(加读锁),不会阻塞其他进程对同一表的读操作,但会阻塞对同一表的写操作。只有当读锁释放后,才能执行其他进程的写操作。在锁释放前不能取其他表。
    在这里插入图片描述

    Transaction-A
    mysql> lock table myisam_lock read;
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select * from myisam_lock;
    9 rows in set (0.00 sec)
    
    mysql> select * from innodb_lock;
    ERROR 1100 (HY000): Table 'innodb_lock' was not locked with LOCK TABLES
    
    mysql> update myisam_lock set v='1001' where k='1';
    ERROR 1099 (HY000): Table 'myisam_lock' was locked with a READ lock and can't be updated
    
    mysql> unlock tables;
    Query OK, 0 rows affected (0.00 sec)
    
    Transaction-B
    mysql> select * from myisam_lock;
    9 rows in set (0.00 sec)
    
    mysql> select * from innodb_lock;
    8 rows in set (0.01 sec)
    
    mysql> update myisam_lock set v='1001' where k='1';
    Query OK, 1 row affected (18.67 sec)
    

    独占写锁

    对MyISAM表的写操作(加写锁),会阻塞其他进程对同一表的读和写操作,只有当写锁释放后,才会执行其他进程的读写操作。在锁释放前不能写其他表。
    在这里插入图片描述

    Transaction-A
    mysql> set autocommit=0;
    Query OK, 0 rows affected (0.05 sec)
    
    mysql> lock table myisam_lock write;
    Query OK, 0 rows affected (0.03 sec)
    
    mysql> update myisam_lock set v='2001' where k='2';
    Query OK, 1 row affected (0.00 sec)
    
    mysql> select * from myisam_lock;
    9 rows in set (0.00 sec)
    
    mysql> update innodb_lock set v='1001' where k='1';
    ERROR 1100 (HY000): Table 'innodb_lock' was not locked with LOCK TABLES
    
    mysql> unlock tables;
    Query OK, 0 rows affected (0.00 sec)
    
    Transaction-B
    mysql> select * from myisam_lock;
    9 rows in set (42.83 sec)
    

    总结:表锁,读锁会阻塞写,不会阻塞读。而写锁则会把读写都阻塞

    查看加锁情况

    show open tables; 1表示加锁,0表示未加锁。

    mysql> show open tables where in_use > 0;
    +----------+-------------+--------+-------------+
    | Database | Table       | In_use | Name_locked |
    +----------+-------------+--------+-------------+
    | lock     | myisam_lock |      1 |           0 |
    +----------+-------------+--------+-------------+
    

    分析表锁定

    可以通过检查table_locks_waited 和 table_locks_immediate 状态变量分析系统上的表锁定:show status like ‘table_locks%’

    mysql> show status like 'table_locks%';
    +----------------------------+-------+
    | Variable_name              | Value |
    +----------------------------+-------+
    | Table_locks_immediate      | 104   |
    | Table_locks_waited         | 0     |
    +----------------------------+-------+
    

    table_locks_immediate: 表示立即释放表锁数。
    table_locks_waited: 表示需要等待的表锁数。此值越高则说明存在着越严重的表级锁争用情况。

    此外,MyISAM的读写锁调度是写优先,这也是MyISAM不适合做写为主表的存储引擎。因为写锁后,其他线程不能做任何操作,大量的更新会使查询很难得到锁,从而造成永久阻塞。

    什么场景下用表锁

    InnoDB默认采用行锁,在未使用索引字段查询时升级为表锁。MySQL这样设计并不是给你挖坑。它有自己的设计目的。

    即便你在条件中使用了索引字段,MySQL会根据自身的执行计划,考虑是否使用索引(所以explain命令中会有possible_key 和 key)。如果MySQL认为全表扫描效率更高,它就不会使用索引,这种情况下InnoDB将使用表锁,而不是行锁。因此,在分析锁冲突时,别忘了检查SQL的执行计划,以确认是否真正使用了索引。

    第一种情况:全表更新。事务需要更新大部分或全部数据,且表又比较大。若使用行锁,会导致事务执行效率低,从而可能造成其他事务长时间锁等待和更多的锁冲突。

    第二种情况:多表查询。事务涉及多个表,比较复杂的关联查询,很可能引起死锁,造成大量事务回滚。这种情况若能一次性锁定事务涉及的表,从而可以避免死锁、减少数据库因事务回滚带来的开销。

    页锁

    开销和加锁时间介于表锁和行锁之间;会出现死锁;锁定粒度介于表锁和行锁之间,并发处理能力一般。只需了解一下。

    总结

    1. InnoDB 支持表锁和行锁,使用索引作为检索条件修改数据时采用行锁,否则采用表锁。
    2. InnoDB 自动给修改操作加锁,给查询操作不自动加锁
    3. 行锁可能因为未使用索引而升级为表锁,所以除了检查索引是否创建的同时,也需要通过explain执行计划查询索引是否被实际使用。
    4. 行锁相对于表锁来说,优势在于高并发场景下表现更突出,毕竟锁的粒度小。
    5. 当表的大部分数据需要被修改,或者是多表复杂关联查询时,建议使用表锁优于行锁。
    6. 为了保证数据的一致完整性,任何一个数据库都存在锁定机制。锁定机制的优劣直接影响到一个数据库的并发处理能力和性能。

    到这里,Mysql的表锁和行锁机制就介绍完了,若你不清楚InnoDB的行锁会升级为表锁,那以后会吃大亏的。若有打什么不对的地方请指正。


    Linux服务器开发/高级架构师 系统性学习公开课:https://ke.qq.com/course/417774?flowToken=1031343

    Linux服务器开发/架构师面试题、学习资料、教学视频和学习路线图(资料包括C/C++,Linux,golang技术,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,TCP/IP,协程,DPDK,ffmpeg等),免费分享有需要的可以自行添加学习交流群960994558

    在这里插入图片描述

    展开全文
  • 举例解释一下MySQL的表锁和行锁

    千次阅读 2022-02-22 17:24:43
    InnoDB存储引擎支持行锁和表锁,MEMORY和MyISAM等存储引擎只支持表锁。 3.1 MyISAM的表锁 MyISAM存储引擎在执行查询语句(SELECT),会自动给涉及的所有表加读锁,在执行更新操作(UPDATE、DELETE、INSERT等),会...

    一、锁的概述

    在计算机中,锁是协调多个进程或线程并发访问某一资源的一种机制。

    在数据库中,除传统的计算资源(如CPU、RAM、I/O等)的争用以外,数据也是一种供许多用户共享的资源。

    如何保证数据并发访问的一致性、有效性是所有数据库必须解决的一个问题,锁冲突也是影响数据库并发访问性能的一个重要因素。

    从这个角度来说,锁对数据库而言显得尤其重要,也更加复杂。

    二、锁的分类

    2.1 按数据操作的类型分类:

    • 读锁(共享锁):针对同一份数据,多个读操作可以同时进行而不会互相影响。

    • 写锁(排它锁):当前操作没有完成之前,它会阻断其他的写操作或读操作。

    2.2 按数据操作的粒度分:

    • 表锁:操作时,会锁定整个表。开销小,加锁快;不会出现死锁;锁定力度大,发生锁冲突概率高,并发度最低。

    • 行锁:操作时,会锁定当前操作的表的某些行。开销大,加锁慢;会出现死锁;锁定粒度小,发生锁冲突的概率低,并发度高。

    • 页锁:操作时,会锁定当前操作的表的某些页。开销和加锁速度介于表锁和行锁之间;会出现死锁;锁定粒度介于表锁和行锁之间,并发度一般。

    很难笼统地说哪种锁更好,只能就具体应用的特点来说哪种锁更合适!

    仅从锁的角度来说,表级锁更适合于以查询为主,只有少量按索引条件更新数据的应用,如Web 应用;而行级锁则更适合于有大量按索引条件并发更新少量不同数据,同时又有并查询的应用,如一些在线事务处理(OLTP)系统。

    三、MySQL的锁

    相对其他数据库而言,MySQL的锁机制比较简单,其最显著的特点是不同的存储引擎支持不同的锁机制。InnoDB存储引擎支持行锁和表锁,MEMORY和MyISAM等存储引擎只支持表锁。

    3.1 MyISAM的表锁

    MyISAM存储引擎在执行查询语句(SELECT),会自动给涉及的所有表加读锁,在执行更新操作(UPDATE、DELETE、INSERT等),会自动给涉及的表加写锁,这个过程并不需要用户干预。

    为了方便演示,我们利用系统提供的显式加锁指令:

    • 读锁:lock table table_name read;

    • 写锁:lock table table_name write;

    • 解锁:unlock tables;

    建立一个MyISAM存储引擎的表,并插入一些数据:

    create table tb_myisam(
    id INT AUTO_INCREMENT,
    name VARCHAR(30),
    age INT,
    PRIMARY KEY(id)) engine=myisam;
     
    insert into tb_myisam(name,age) value('zhang3',20);
    insert into tb_myisam(name,age) value('li4',21);
    insert into tb_myisam(name,age) value('wang5',22);

    3.1.1 在两个会话终端来演示MyISAM的读锁:

    3.1.2 演示MyISAM的写锁:

    3.2 InnoDB的表锁和行锁

    InnoDB存储引擎在执行更新操作(UPDATE、DELETE、INSERT等),会自动给涉及的表或行加写锁。

    InnoDB存储引擎对于普通SELECT语句,不会加任何锁。如果读的数据正在执行UPDATE或DELETE操作,这时读操作不会等待写锁的释放,而是直接读取该数据的快照,具体读取那份快照数据,和系统的隔离级别有关。

    对于SELECT语句,系统提供了显式加锁指令:

    • 读锁:select * from table_name where ... lock in share mode;

    • 写锁:select * from table_name where ... for update;

    建立一个MyISAM存储引擎的表,并插入一些数据:

    create table tb_innodb (
    id INT AUTO_INCREMENT,
    name VARCHAR(30),
    age INT,
    PRIMARY KEY(id)) engine=innodb;
     
    insert into tb_innodb(name,age) value('zhang3',20);
    insert into tb_innodb(name,age) value('li4',21);
    insert into tb_innodb(name,age) value('wang5',22); 

    为了方便演示,我们需要关闭系统的自动提交

    3.2.1 演示InnoDB表的读锁:

    3.2.2 演示InnoDB表的写锁:

    3.2.3 演示InnoDB行的读锁:

    3.2.4 演示InnoDB行的写锁:

    KunlunDB项目已开源

    【GitHub:】
    https://github.com/zettadb

    【Gitee:】
    https://gitee.com/zettadb

    END

    展开全文
  • 各位对 ”锁“ 这个概念应该都不是很陌生吧,...需要注意的是,每种数据库对于锁的实现都是不同的,并且对于 MySQL 来说,每种存储引擎都可以实现自己的锁策略和锁粒度,比如 InnoDB 引擎支持行锁和表锁,而 MyISAM 引
  • Mysql之数据库锁(表锁和行锁)详解

    千次阅读 2021-06-06 13:16:00
    从对数据的操作粒度分为:表锁 行锁 表锁 表锁特点 MylSAM引擎使用表锁,开销小,加锁快,无死锁,锁定力度大,发生锁冲突的概率最高。 并发度最低 不支持事务 查看数据库锁 SHOW OPEN TABLES in hanyxx; --...
  • 数据库表锁和行锁

    2021-04-19 15:01:44
    表锁 加读锁 加写锁 案例总结 读锁会阻塞写请求,不会阻塞读请求;写操作会阻塞读写操作。 表锁分析 手动加锁 lock table 表名称 read(write),表名称2 read(write)… 释放表锁 unlock tables; 查看哪些表被...
  • mysql表锁和行锁区别是什么发布时间:2020-09-16 14:41:57来源:亿速云阅读:115作者:小新小编给大家分享一下mysql表锁和行锁区别是什么,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家...
  • MySQL 表锁和行锁机制

    2021-03-07 16:38:48
    MySQL 表锁和行锁机制 行锁表锁,是福还是坑?如果你不清楚MySQL加锁的原理,你会被它整的很惨!不知坑在何方?没事,我来给你们标记几个坑。遇到了可别乱踩。通过本章内容,带你学习MySQL的行锁表锁,两种锁的...
  • MySQL 表锁和行锁机制行锁表锁,是福还是坑?如果你不清楚MySQL加锁的原理,你会被它整的很惨!不知坑在何方?没事,我来给你们标记几个坑。遇到了可别乱踩。通过本章内容,带你学习MySQL的行锁表锁,两种锁的优...
  • 细谈数据库表锁和行锁

    万次阅读 多人点赞 2019-09-19 21:59:00
    表锁1. 特点2. MDL元数据锁(metadata lock)1. 特点3. MDL锁的坑————给一个小表加字段1. 问题描述3. online ddl(ddl:更改表结构)3. 行锁1. 行锁特性2. 两阶段锁协议4. 死锁1. 处理死锁策略2. 死锁检测(⭐...
  • MySQL之锁机制(表锁和行锁)锁的定义锁的分类表锁表锁特点表锁(读锁)表锁(写锁)总结表锁定分析行锁(重点)行锁特点并发事务产生的问题事务隔离级别模拟数据行锁基本演示行锁演示结论索引失效间隙锁什么是间隙锁...
  • MySQL的表锁,其实是极为鸡肋的一个东西,几乎一般很少会用到,表锁分为两种,一种就是表锁,一种是表级的意向锁。 首先说表锁,这个表锁,可以用如下语法来加: LOCK TABLES xxx READ:这是加表级共享锁 LOCK ...
  • 另外,为了允许行锁和表锁共存,实现多粒度锁机制,InnoDB 还有两种内部使用的意向锁(Intention Locks),这两种意向锁都是表锁: 意向共享锁(IS):事务打算给一个数据行加共享锁前,必须先取得该表的 IS 锁 意向...
  • 61 表锁和行锁互相之间的关系以及互斥规则是什么呢?l.pdf
  • 根据加锁的范围,MySQL 里面的锁大致可以分成全局锁、表级锁和行锁三类。全局锁就是对整个数据库实例加锁。MySQL 提供了一个加全局读锁的方法,命令是 Flush tables with read lock (FTWRL)。 执行FTWRL会阻塞:数据...
  • mysql中表锁和行锁的区别是:1、表锁偏向myisam存储引擎,行锁偏向innodb存储引擎;2、表锁开销小,行锁开销大;3、表锁的锁粒度大,行锁的锁粒度小。本篇文章将对MySQL的表锁和行锁进行详细介绍,以及分析对比之间...
  • MySQL深入浅出之全局锁和表锁和行锁

    千次阅读 2021-07-05 09:31:22
    行锁 mysql的行锁属于各个引擎自己的功能 不是所有的引擎都有行锁, 比如MyISam, 这也是InnoDB替代他的原因 不支持行锁, 意味着并发控制只能使用表锁, 同一张表任意时刻只能有一个更新执行, 会影响业务并发度 4.1 ...
  • 1.事务的四大特性 原子性(Atomicity,或... 一致性:事务操作预期结果保持一致。 隔离性:就是一种防止事务污染的一种机制。 持久性:数据一旦提交,写入磁盘。 锁的作用:资源竞争、防止污染(数据锁,程序锁)...
  • 锁定对象可以是逻辑单元(如数据库、表、记录、列、索引等),也可以是物理单元(如数据页、索引页等)。...锁定的粒度与系统的并发度并发控制的开销密切相关。一般地,锁定的粒度越大,需要锁定的对象就...
  • 主要介绍了MySQL 行锁和表锁的含义及区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 行业-61 表锁和行锁互相之间的关系以及互斥规则是什么呢?l.rar
  • mysql表锁和行锁区别

    2021-01-19 02:48:42
    原标题:mysql表锁和行锁区别一、表锁特点:偏向MyISAM存储引擎,开销小,加锁快;无死锁;锁定粒度大,发生锁冲突的概率最高,并发度最低。我们在编辑表,或者执行修改表的事情了语句的时候,一般都会给表加上表锁,...
  • MySQL 表锁和行锁机制 行锁表锁,是福还是坑?如果你不清楚MySQL加锁的原理,你会被它整的很惨!不知坑在何方?没事,我来给你们标记几个坑。遇到了可别乱踩。通过本章内容,带你学习MySQL的行锁表锁,两种锁的...
  • mysql数据库表锁行锁

    千次阅读 2022-03-13 20:29:19
    mysql的2种常见的锁:表锁和行锁 间隙锁的危害
  • 本文全面讲解了MySQL中锁包括表锁,行锁,共享锁,排它锁,间隙锁的详细使用方法
  • Mysql表锁行锁

    2021-11-23 19:51:34
    存在是为了协调行锁和表锁的关系,支持多粒度(表锁与行锁)的锁并存;意向锁是InnoDB自动加的,不需用户干预。 加了意向锁以后,有了事务冲突就不会全表扫描了,而是根据意向锁进行相应的加锁 记录锁(record lock...
  • 学习丁奇(林晓斌)老师MySQL实战45讲课程后提炼的笔记!!! MySQL的全局锁、表级锁和行锁

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,079
精华内容 18,431
关键字:

表锁和行锁