数据库——MySQL事务

最新推荐文章于 2023-09-19 11:30:39 发布
最新推荐文章于 2023-09-19 11:30:39 发布
阅读量204 收藏
点赞数
分类专栏： # MySQL 文章标签： mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38938338/article/details/105195659
版权

文章目录

1. 事务的概念

事务由单独单元的一个或者多个sql语句组成，在这个单元中，每个mysql语句时相互依赖的。而整个单独单元作为一个不可分割的整体，如果单元中某条sql语句一旦执行失败或者产生错误，整个单元将会回滚，也就是所有受到影响的数据将会返回到事务开始以前的状态。如果单元中的所有sql语句均执行成功，则事务被顺利执行。

要么全部执行，要么全部不执行
要么全部成功，要么全部失败
要么全部有效，要么全部无效

2. 存储引擎

查看mysql支持的存储引擎

show engines

存储引擎分类

在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务

3. 事务的属性（ACID）

  • 原子性（Atomicity，或称不可分割性）

一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

  • 一致性（Consistency）

一个事务的执行会使数据从一个一致状态切换到另一个一致的状态。在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

  • 隔离性（Isolation，又称独立性）

一个事务的执行不受其他事务的干扰。数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。

  • 持久性（Durability）

一个事务一旦提交，对数据的修改就是永久的。

4. 事务的创建

隐式事务
  • 事务没有明显的开启和结束的标记
  • 比如insert、update、delete语句
  • 自动提交的属性默认开启

SHOW VARIABLES LIKE ‘autocommit’;

Variable_nameValue
autocommion
  • 存在的问题

比如有多条delete语句，没有办法让这些语句统一为一个事务

显式事务
  • 前提：必须先设置自动提交功能为禁用
# 步骤1：开启事务
# 只针对当前事务，当前事务结束后，自动提交功能恢复开启
set autocommit=0;
start transaction;# 可选的
# 步骤2：编写事务中的sql语句(select insert update delete)
select ...
insert ...
update ...
delete ...
# 步骤3：结束事务
commit;# 提交事务
rollback;# 回滚事务

5. 隔离机制

原因

对于同时运行的多个事务，当这些事务访问数据库中的相同的数据时，如果没有采取必要的隔离机制就会产生并发问题： 脏读，不可重复读，幻读

  • 脏读（读取未提交数据）

A事务读取B事务尚未提交的数据，此时如果B事务发生错误并执行回滚操作，那么A事务读取到的数据就是脏数据。

这种情况常发生于转账与取款操作中

时间顺序转账事务取款事务
1开始事务
2开始事务
3查询账户余额为2000元
4取款1000元，余额被更改为1000元
5查询账户余额为1000元（产生脏读）
6取款操作发生未知错误，事务回滚，余额变更为2000元
7转入2000元，余额被更改为3000元（脏读的1000+2000）
8提交事务
备注按照正确逻辑，此时账户余额应该为4000元
  • 不可重复读（前后多次读取，数据内容不一致）

事务A在执行读取操作，由于整个事务A比较大，前后读取同一条数据需要经历很长的时间 。而在事务A第一次读取数据后，事务B执行更新操作，此时事务A再次读取，发现和之前的数据不一样了，也就是数据不重复了，系统不可以在同一个事务内读取到不重复的数据，称为不可重复读

  • 幻读（前后多次读取，数据总量不一致）

事务A从数据表中读取了一个字段，而后事务B在该表中又插入了一些记录，事务A再次读取该字段，发现在同一个事务内前后两次读取到的数据记录总量不一致

事务隔离级别
  1. MySQL 事务隔离其实是依靠锁来实现的
  • MyISAM：表锁、InnoDB：行锁+表锁
  • 行锁 / 记录锁：作用在索引上
  • 间隙锁 Gap Locks：是开区间，用于阻止其他事务在该间隙内插入新记录，而自身事务是允许在该间隙内插入数据的
  • 临键锁 Next-Key Locks：是左开右闭区间，即行锁+间隙锁
  • 共享锁 S / 排他锁 X ：尽管共享锁/排他锁是行锁，与间隙锁无关，但一个事务在请求共享锁/排他锁时，获取到的结果却可能是行锁，也可能是间隙锁，也可能是临键锁，这取决于数据库的隔离级别以及查询的数据是否存在
行锁兼容性加锁方式
S锁：共享锁/读加了S锁的记录，允许其他事务再加S锁，不允许其他事务再加X锁select…lock in share mode
X锁：排他锁/写加了X锁的记录，不允许其他事务再加S锁或者X锁select…for update
  • 意向共享锁 IS /意向排他锁 IX：属于表锁，且取得意向共享锁/意向排他锁是取得共享锁/排他锁的前置条件
  • 插入意向锁(IIX)
  • 自增锁
  • 死锁问题：设置锁等待超时参数、优化SQL语句
    • 如果不同的程序会并发存取多个表，应尽量约定以相同的顺序来访问表
    • 如果要更新记录，应该申请排他锁，而不先申请共享锁，更新时再申请排他锁，因为当用户申请排他锁时，其他事务可能又已经获得了相同记录的共享锁，从而造成锁冲突，甚至死锁
    • 在REPEATABLE-READ隔离级别下，如果两个线程同时对相同条件记录用SELECT…FOR UPDATE加排他锁，在没有符合该条件记录情况下，两个线程都会加锁成功。程序发现记录尚不存在，就试图插入一条新记录，如果两个线程都这么做，就会出现死锁。这种情况下，将隔离级别改成READ COMMITTED，就可避免问题
  1. READ UNCOMMITTED

读取未提交的数据，该隔离级别默认不加锁，所以它的并发性最高，一致性最差。

  1. READ COMMITTED

读取提交的数据。但是，可能出现多次读取的数据结果、数据总量不一致（不可重复读，幻读）

  • MySQL 采用了 MVCC (多版本并发控制 Multi-Version Concurrency Control) 的方式，数据每次变化都会产生一个新的版本，版本=数据本身+事务id
  • 普通的select不加锁，使用快照读(snapshot read，这是一种不加锁的一致性读，底层使用MVCC来实现)，该隔离级别每次执行语句的时候都重新生成一次快照，能防止脏读
  • 加锁的select(select … in share mode / select … for update)、update、delete等语句，使用当前读，除了在外键约束检查(foreign-key constraint checking)以及重复键检查(duplicate-key checking)时会封锁区间，其他时刻都只使用行锁，不使用间隙锁(gap lock)、临键锁(next-key lock)
  1. REPEATABLE READ（InnoDB默认的隔离级别）

可以重复读取，避免了脏读和不可重复度，使用MVCC避免了读数据时的幻读问题，写数据时依旧可能出现幻读。

  • 普通的select不加锁，使用快照读(snapshot read，这是一种不加锁的一致性读，底层使用MVCC来实现)，该隔离级别在事务开始的时候生成一个当前事务全局性的快照
  • 加锁的select(select … in share mode / select … for update)、update、delete等语句，使用当前读，加锁策略取决于它们是否在唯一索引上使用了唯一的查询条件
    • 在唯一索引上使用唯一的查询条件，只使用行锁(record lock)，而不会封锁记录之间的间隔，即不会使用间隙锁(gap lock)与临键锁(next-key lock)
    • 范围查询条件或者是非唯一索引，使用间隙锁与临键锁，锁住索引记录之间的范围，避免范围间插入记录，以避免产生不可重复读和部分幻读
对比READ COMMITTEDREPEATABLE READ
普通select，使用快照读(snapshot read)，这是一种不加锁的一致性读，底层使用MVCC来实现允许读已提交的数据，每一次一致性读操作都会重新生成一次快照，避免脏读事务开始的时候生成一个当前事务全局性的快照，避免脏读和不可重复读
加锁的select(select … in share mode / select … for update)、update、delete，使用当前读只使用行锁，没法避免不可重复读和幻读加锁策略取决于它们是否在唯一索引上使用了唯一的查询条件，可避免不可重复读和部分幻读
  1. SERIALIZABLE

读的时候加共享锁，也就是其他事务可以并发读，但是不能写。
写的时候加排它锁，其他事务不能并发写也不能并发读。
这是一致性最好，但并发性最差的隔离级别。

所有select语句都会被隐式的转化为select … in share mode，也就是默认上共享读锁(S锁)。所以，如果事务A先执行如下sql之后，会尝试获取所查询行的IS锁(和别的IS、IX锁是兼容的)，这时别的事务也能获取这些行的IS锁甚至是S锁。

但是如果接下来，事务A如果update或delete其中的某些行，这时就获取了X锁，别的事务即便是执行普通的select语句也会阻塞，因为它们尝试获取IS锁，但是IS锁和X锁是互斥的，这样就避免了读脏、不可重复读以及幻读，所有事务就只能串行了。

隔离级别脏读不可重复读幻读
读未提交√√√
读已提交x√√
可重复读xx√
可串行化xxx
查看并设置
# 查看当前会话隔离级别
SELECT @@session.transaction_isolation;
# 查看当前系统隔离级别
SELECT @@global.transaction_isolation;
# 设置当前会话隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;
# 设置当前系统隔离级别
SET GLOBAL TRANSACTION ISOLATION LEVEL REPEATABLE READ;
示例
  1. 设置隔离级别READ-UNCOMMITTED，事务A企图修改数据
mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @@session.transaction_isolation;
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-UNCOMMITTED                |
+---------------------------------+
1 row in set (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 李四     |
+----+----------+
2 rows in set (0.00 sec)

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update stu set stu_name='王五' where id=2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 王五     |
+----+----------+
2 rows in set (0.00 sec)
  1. 此时，有事务B进行读操作
mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @@session.transaction_isolation;
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-UNCOMMITTED                |
+---------------------------------+
1 row in set (0.00 sec)

mysql> use test1;
Database changed
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 王五     |
+----+----------+
2 rows in set (0.00 sec)
  1. 事务A遇到未知错误，进行回滚操作
mysql> rollback;
Query OK, 0 rows affected (0.09 sec)

mysql> commit;
Query OK, 0 rows affected (0.00 sec)
  1. 此时事务B再进行读操作，出现脏读
mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 李四     |
+----+----------+
2 rows in set (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.00 sec)
  1. 提交A、B事务，修改事务隔离级别为READ-COMMITTED
mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @@session.transaction_isolation;
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-COMMITTED                  |
+---------------------------------+
1 row in set (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 李四     |
+----+----------+
2 rows in set (0.00 sec)

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> update stu set stu_name='赵六' where id=2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 赵六     |
+----+----------+
2 rows in set (0.00 sec)
  1. 此时事务B进行读操作，没有出现脏读
mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @@session.transaction_isolation;
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| READ-COMMITTED                  |
+---------------------------------+
1 row in set (0.00 sec)

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 李四     |
+----+----------+
2 rows in set (0.00 sec)
  1. 但此时若事务A提交事务
mysql> commit;
Query OK, 0 rows affected (0.21 sec)
  1. 事务B尚未提交，再次读取数据，出现不可重复读
mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 赵六     |
+----+----------+
2 rows in set (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.21 sec)
  1. 提交事务，修改隔离级别为REPEATABLE-READ，A事务继续修改
mysql> SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE read;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @@session.transaction_isolation;;
+---------------------------------+
| @@session.transaction_isolation |
+---------------------------------+
| REPEATABLE-READ                 |
+---------------------------------+
1 row in set (0.00 sec)

ERROR:
No query specified

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 赵六     |
+----+----------+
2 rows in set (0.00 sec)

mysql> update stu set stu_name='孙七' where id=2;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 孙七     |
+----+----------+
2 rows in set (0.00 sec)
  1. 此时，事务B在事务A修改数据前后进行两次读操作，没有出现脏读、不可重复读
mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 赵六     |
+----+----------+
2 rows in set (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 赵六     |
+----+----------+
2 rows in set (0.00 sec)
  1. 此时提交A事务，再重新开启A事务
mysql> commit;
Query OK, 0 rows affected (0.11 sec)

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from stu;
+----+----------+
| id | stu_name |
+----+----------+
|  1 | 张三     |
|  2 | 孙七     |
+----+----------+
2 rows in set (0.00 sec)
  1. 此时B事务插入一条数据
mysql> insert into stu values(null,'钱八');
Query OK, 1 row affected (0.00 sec)
  1. A事务将所有数据的 stu_name 统一更新为 cc，超时错误，原因是出现幻读
mysql> update stu set stu_name='cc';
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
  1. 设置为SERIALIZABLE就可以解决脏读、不可重复读、幻读问题

参考链接

ManbaBryant
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql——事务
12-14
文章目录mysql——事务四大特性概念使用事务四大隔离级别版本链ReadView读视图 mysql——事务 四大特性 原子性，一致性，隔离性，持久性简称ACID 以转账的例子解释ACID，A向B转1000元 原子性： A扣1000元，B加1000元...
数据库+mysql+面试题
最新发布
10-18
面试题,包括数据库基础知识、索引、事务等方面 MySQL的主从复制原理以及流程 主：binlog线程——记录下所有改变了数据库数据的语句，放进master上的binlog中； 从：io线程——在使用start slave 之后，负责从...
数据库MVCC多版本并发控制原理
Eric的博客
12-04 9871
MVCC实现原理 频繁的加锁会带来什么问题？ 读数据的时候没办法修改。修改数据的时候没办法读取，极大的降低了数据库性能。 数据库是如何解决加锁后的性能问题的？ MVCC 多版本控制实现读取数据不用加锁， 可以让读取数据同时修改。修改数据时同时可读取。 一、什么是MVCC？ MVCC是在并发访问数据库时，通过对数据做多版本管理，避免因为写锁的阻塞而造成读数据的并发阻塞问题。 通俗的讲就是MVCC通过保存数据的历史版本，根据比较版本号来处理数据的是否显示，从而达到读取数据的时候不需要加锁就可以
MVCC及实现原理
GSON的博客
10-15 1万+
！首先声明，MySQL 的测试环境是 5.7 前提概要 什么是 MVCC 什么是当前读和快照读？ 当前读，快照读和 MVCC 的关系 MVCC 实现原理 隐式字段 undo日志 Read View 整体流程 MVCC 相关问题 RR 是如何在 RC 级的基础上解决不可重复读的？ RC, RR 级别下的 InnoDB 快照读有什么不同？ 一、前提概要 1、什么是 MVCC ? MVCCMVCC，全称Multi-Version Concurrency Co.
一篇详解MVCC多版本并发控制的原理
weixin_56602545的博客
09-19 1781
MVCC（Multi-Version Concurrency Control），即多版本并发控制，在MySQL InnoDB中处理并发时，不加锁和非阻塞并发读，提高并发读性能的一种机制。MVCC维持了数据的多个版本，使得并发读写时没有冲突。
MVCC多版本并发控制机制原理
DrMickeys的博客
02-05 782
MVCC多版本并发控制机制原理
正确理解MySQL的MVCC及实现原理
qq_43568704的博客
09-15 2832
MVCC多版本并发控制 目录 MVCC多版本并发控制 前提概要 什么是MVCC? 什么是当前读和快照读？ 当前读，快照读和MVCC的关系 MVCC的实现原理 隐式字段 undo日志 Read View(读视图) 整体流程 MVCC相关问题 RR是如何在RC级的基础上解决不可重复读的？ RC,RR级别下的InnoDB快照读有什么不同？ 转载于：https://blog.csdn.net/SnailMann/article/details/94724197?utm_medium=d
MySQL数据库：事务隔离级别.pptx
05-29
了解 —— 事务隔离级别的概念； 理解 —— 事务隔离的四种级别； 掌握 —— 事务隔离级别的设置； 事务隔离级别 事务隔离：每一个事务都有一个所谓的隔离级，它定义了用户彼此之间隔离和交互的程度。隔离性强制对...
MySQL数据库：事务的概述、ACID.pptx
05-29
在MySQL环境中，事务由作为一个单独单元的一个或多个SQL语句组成。这个单元中的每个SQL语句是互相依赖的，而且单元作为一个整体是不可分割的。如果单元中的一个语句不能完成，整个单元就会回滚（撤销），所有影响到...
面试准备——MySql基础篇
12-15
在MySQL Client中输入的SQL语句通过TCP连接发送到MySQL Server，默认端口号是3306，即如果发送到本机MySQL Server，地址就是127.0.0.1:3306，也可以只安装MySQL Client，然后连接到远程MySQL Server。假设远程MySQL ...
MVCC多版本并发控制实现原理
ningkangming的博客
01-28 1046
InnoDB 是一个数据多版本的存储引擎。它保留有关已更改行的旧版本的信息，以支持并发性和回滚等事务性特性。此信息存储在系统表空间中，或在undo 表空间中称为回滚段的数据结构中。InnoDB使用回滚段中的信息来执行事务回滚中所需的撤消操作，它还会使用这些信息来构建具有一致性读的行的早期版本（即多版本快照读）。
MVCC（多版本并发控制）机制和原理
极客神殿
03-12 1897
是一种常见的并发控制机制，常用于数据库管理系统中，其主要思想是为每个事务分配一个唯一的时间戳，并使用时间戳来区分事务的版本，以避免读取已被修改或正在被修改的数据。MVCC机制的主要原理是通过创建多个版本的数据，从而使并发事务不会互相干扰。总之，MVCC机制通过为每个事务分配唯一的时间戳，并创建多个版本的数据来实现并发控制。这种机制可以避免数据冲突和死锁等并发控制问题，从而提高数据库系统的性能和可靠性。
MVCC(多版本并发控制)原理
weixin_44941128的博客
06-13 4172
一、概念 MVCC(Multi-Version Concurrency Control)实在mysql的innodb引擎中yong'lai
MVCC的庐山真面目
qq_36180997的博客
01-03 247
概念 MVCC，全称Multi-Version Concurrency Control，即多版本并发控制。MVCC是一种并发控制的方法，一般在数据库管理系统中，实现对数据库的并发访问，在编程语言中实现事务内存。 使用MVCC的好处 多版本并发控制（MVCC）是一种用来解决读-写冲突的无锁并发控制，在并发读写数据库时，可以做到在读操作时不用阻塞写操作，写操作也不用阻塞读操作，提高了数据库并发读写的性能。 同时还可以解决脏读，幻读，不可重复读等事务隔离问题，但不能解决更新丢失问题（后面解释）。 注意 本文
mysql中MVCC多版本并发控制原理的详解
热门推荐
nandao158的博客
04-21 1万+
今天我们分享mysql中MVCC多版本并发控制原理的详解 一、MVCC定义 1、MVCC简介 MVCC，全称Multi-Version Concurrency Control，即多版本井发控制,MVCC是一种并发控制的方法，一般在数据库管理系统中,实现对数据库的并发访问，在编程语言中实现事务内存。 MVCC在MysQL InnoDB中的实现主要是为了提高数据库并发性能，用更好的方式去处理读写冲突。做到即使有读写冲突时，也能做到不加锁，非阻塞并发读。 2、当前读 像select lock in sha.
【mysql 】 mvcc（多版本并发控制）原理的理解
李光 未来科技
07-22 1135
mysql mvcc 不知道的看一看
MysqlMvcc多版本并发控制实现原理
qq_54494937的博客
03-11 1230
1、什么是MVCC？ MVCC是在并发访问数据库时，通过对数据做多版本管理，避免因为写锁的阻塞而造成读数据的并发阻塞问题。 通俗的讲就是MVCC通过保存数据的历史版本，根据比较版本号来处理数据的是否显示，从而达到读取数据的时候不需要加锁就可以保证事务隔离性的效果 2、Innodb MVCC实现的核心知识点 undo log（回滚日志） 之前对undo log的作用只提到了回滚操作实现原子性，现在需要知道的另一个作用就是实现MVCC多版本控制器。 undo log细分为俩种，insert时产生的undo
【MVCC多版本并发控制】MVCC 机制的原理及实现，什么是MVCC,多版本并发控制
世上哪有什么岁月静好,不过是有人替你负重前行
04-19 1775
什么是 MVCC MVCC (Multiversion Concurrency Control) 中文全程叫多版本并发控制，是现代数据库（包括 MySQL、Oracle、PostgreSQL 等）引擎实现中常用的处理读写冲突的手段，目的在于提高数据库高并发场景下的吞吐性能。 如此一来不同的事务在并发过程中，SELECT 操作可以不加锁而是通过 MVCC 机制读取指定的版本历史记录，并通过一些手段保证保证读取的记录值符合事务所处的隔离级别，从而解决并发场景下的读写冲突。 先来了解一下什么是版本链： 什么是
MySQL的varchar水真的太深了——InnoDB记录存储结构
08-10
确实，MySQL的varchar类型在InnoDB存储引擎中的存储结构比较复杂。在InnoDB中，每个记录都被存储为一个B+树节点，每个节点都有一个固定大小的页，通常为16KB。 当一个varchar类型的列被插入到InnoDB表中时，它会被...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值