深入理解Mysql的四种隔离级别（深入理解mysql的四种隔离级别是什么）

25-02-07 25

本文将介绍深入理解Mysql的四种隔离级别的详细情况，特别是关于深入理解mysql的四种隔离级别是什么的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关

本文将介绍深入理解Mysql的四种隔离级别的详细情况，特别是关于深入理解mysql的四种隔离级别是什么的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于Mysql 事务的四种隔离级别、mysql 事宜的四种隔离级别、mysql 四种隔离级别、MySQL事务的四种隔离级别的知识。

本文目录一览：

深入理解Mysql的四种隔离级别（深入理解mysql的四种隔离级别是什么）
Mysql 事务的四种隔离级别
mysql 事宜的四种隔离级别
mysql 四种隔离级别
MySQL事务的四种隔离级别

深入理解Mysql的四种隔离级别（深入理解mysql的四种隔离级别是什么）

一、首先什么是事务？

事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。

事务的结束有两种，当事务中的所以步骤全部成功执行时，事务提交。如果其中一个步骤失败，将发生回滚操作，撤消撤消之前到事务开始时的所以操作。

二、事务的 ACID

事务具有四个特征：原子性（ Atomicity ）、一致性（ Consistency ）、隔离性（ Isolation ）和持续性（ Durability ）。这四个特性简称为 ACID 特性。

1 、原子性。事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做

2 、一致性。事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含成功事务提交的结果时，就说数据库处于一致性状态。如果数据库系统运行中发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是不一致的状态。

3 、隔离性。一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。

4 、持续性。也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

三、MysqL的四种隔离级别

sql标准定义了4类隔离级别，包括了一些具体规则，用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。

Read Uncommitted（读取未提交内容）

在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。

Read Committed（读取提交内容）

这是大多数数据库系统的默认隔离级别（但不是MysqL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。

Repeatable Read（可重读）

这是MysqL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读（Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。

Serializable（可串行化）

这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：

脏读(Drity Read)：某个事务已更新一份数据，另一个事务在此时读取了同一份数据，由于某些原因，前一个RollBack了操作，则后一个事务所读取的数据就会是不正确的。

不可重复读(Non-repeatable read):在一个事务的两次查询之中数据不一致，这可能是两次查询过程中间插入了一个事务更新的原有的数据。

幻读(Phantom Read):在一个事务的两次查询中数据笔数不一致，例如有一个事务查询了几列(Row)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。
在MysqL中，实现了这四种隔离级别，分别有可能产生问题如下所示：

四、测试MysqL的隔离级别

下面，将利用MysqL的客户端程序，我们分别来测试一下这几种隔离级别。

测试数据库为demo，表为test；表结构：

两个命令行客户端分别为A，B；不断改变A的隔离级别，在B端修改数据。

（一）、将A的隔离级别设置为read uncommitted(未提交读)

A：启动事务，此时数据为初始状态

B：启动事务，更新数据，但不提交

A：再次读取数据，发现数据已经被修改了，这就是所谓的“脏读”

B：回滚事务

A：再次读数据，发现数据变回初始状态

经过上面的实验可以得出结论，事务B更新了一条记录，但是没有提交，此时事务A可以查询出未提交记录。造成脏读现象。未提交读是最低的隔离级别。

（二）、将客户端A的事务隔离级别设置为read committed(已提交读)

A：启动事务，此时数据为初始状态

B：启动事务，更新数据，但不提交

A：再次读数据，发现数据未被修改

B：提交事务

A：再次读取数据，发现数据已发生变化，说明B提交的修改被事务中的A读到了，这就是所谓的“不可重复读”

经过上面的实验可以得出结论，已提交读隔离级别解决了脏读的问题，但是出现了不可重复读的问题，即事务A在两次查询的数据不一致，因为在两次查询之间事务B更新了一条数据。已提交读只允许读取已提交的记录，但不要求可重复读。

(三)、将A的隔离级别设置为repeatable read(可重复读)

A：启动事务，此时数据为初始状态

B：启动事务，更新数据，但不提交

A：再次读取数据，发现数据未被修改

B：提交事务

A：再次读取数据，发现数据依然未发生变化，这说明这次可以重复读了

B：插入一条新的数据，并提交

A：再次读取数据，发现数据依然未发生变化，虽然可以重复读了，但是却发现读的不是最新数据，这就是所谓的“幻读”

A：提交本次事务，再次读取数据，发现读取正常了

由以上的实验可以得出结论，可重复读隔离级别只允许读取已提交记录，而且在一个事务两次读取一个记录期间，其他事务部的更新该记录。但该事务不要求与其他事务可串行化。例如，当一个事务可以找到由一个已提交事务更新的记录，但是可能产生幻读问题(注意是可能，因为数据库对隔离级别的实现有所差别)。像以上的实验，就没有出现数据幻读的问题。

(四)、将A的隔离级别设置为可串行化(Serializable)

A：启动事务，此时数据为初始状态

B：发现B此时进入了等待状态，原因是因为A的事务尚未提交，只能等待（此时，B可能会发生等待超时）

A：提交事务

B：发现插入成功

serializable完全锁定字段，若一个事务来查询同一份数据就必须等待，直到前一个事务完成并解除锁定为止。是完整的隔离级别，会锁定对应的数据表格，因而会有效率的问题。

总结

以上就是这篇文章全部内容了，希望本文的内容对大家的学习或者能有所帮助，如果有疑问大家可以留言交流。

Mysql 事务的四种隔离级别

开发工作中我们会使用到事务，那你们知道事务又分哪几种吗？
MYSQL标准定义了4类隔离级别，用来限定事务内外的哪些改变是可见的，哪些是不可见的。
低的隔离级一般支持更高的并发处理，并拥有更低的系统开销。
隔离级别由低到高：Read Uncommitted Read Uncommitted（读取未提交内容）

在该隔离级别，所有事务都可以看到其他未提交(commit)事务的执行结果。
本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。
读取未提交的数据，也被称之为脏读（Dirty Read）。[窗口A]:

mysql> set GLOBAL tx_isolation=''READ-UNCOMMITTED'';
Query OK, 0 rows affected (0.00 sec)

mysql> quit;
Bye

[root@vagrant-centos65 ~]# mysql -uroot -pxxxx(重新登录)

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

mysql> use test;
Database changed
mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from user;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | b    |
+----+------+
2 rows in set (0.00 sec)

[窗口B]:
mysql> select @@tx_isolation;
+------------------+
| @@tx_isolation   |
+------------------+
| READ-UNCOMMITTED |
+------------------+
1 row in set (0.00 sec)

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

mysql> insert into test.user values (3, ''c'');
Query OK, 1 row affected (0.00 sec)

mysql> select * from user;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | b    |
|  3 | c    |
+----+------+
3 rows in set (0.00 sec)

//目前为止，窗口B并未commit;

[窗口A]:
mysql> select * from user ;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | b    |
|  3 | c    |
+----+------+
3 rows in set (0.00 sec)Read Committed（读取提交内容）

这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。
它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。
这种隔离级别也支持所谓的不可重复读（NonrepeatableRead），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一 select 可能返回不同结果。[窗口A]：

mysql> SET GLOBAL tx_isolation=''READ-COMMITTED'';
Query OK, 0 rows affected (0.00 sec)

mysql> quit;
Bye

[root@vagrant-centos65 ~]# mysql -uroot -pxxxx(重新登录)

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

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

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | b    |
+----+------+
2 rows in set (0.00 sec)

[窗口B]:

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

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

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | b    |
+----+------+
2 rows in set (0.00 sec)

mysql> delete from test.user where id=1;
Query OK, 1 row affected (0.00 sec)

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
+----+------+
1 row in set (0.00 sec)

[窗口A]:

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  1 | a    |
|  2 | b    |
+----+------+
2 rows in set (0.00 sec)

[窗口B]:

mysql> commit;
Query OK, 0 rows affected (0.02 sec)

[窗口A]:

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
+----+------+
1 row in set (0.00 sec)Repeatable Read（可重读）

这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。
不过理论上，这会导致另一个棘手的问题：幻读（Phantom Read）。
简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。
InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。[窗口A]:

mysql> SET GLOBAL tx_isolation=''REPEATABLE-READ'';
Query OK, 0 rows affected (0.00 sec)

mysql> quit;
Bye

[root@vagrant-centos65 ~]# mysql -uroot -pxxxx(重新登录)

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

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

[窗口B]:

mysql> quit;
Bye

[root@vagrant-centos65 ~]# mysql -uroot -pxxxx(重新登录)

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

mysql> insert into test.user values (4, ''d'');
Query OK, 1 row affected (0.00 sec)

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
|  4 | d    |
+----+------+
2 rows in set (0.00 sec)

[窗口A]:

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
+----+------+
1 rows in set (0.00 sec)

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

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
|  4 | d    |
+----+------+
2 rows in set (0.00 sec)Serializable（序列化执行）

这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。
简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。 [窗口A]:

mysql> SET GLOBAL tx_isolation=''SERIALIZABLE'';
Query OK, 0 rows affected (0.00 sec)

mysql> quit;
Bye

[root@vagrant-centos65 ~]# mysql -uroot -pxxxx(重新登录)

mysql> SELECT @@tx_isolation;
+----------------+
| @@tx_isolation |
+----------------+
| SERIALIZABLE   |
+----------------+
1 row in set (0.00 sec)

mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
|  4 | d    |
+----+------+
2 rows in set (0.00 sec)

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

mysql> insert into test.user values (5, ''e'');
Query OK, 1 row affected (0.00 sec)

[窗口B]:

mysql> quit;
Bye

[root@vagrant-centos65 ~]# mysql -uroot -pxxxx(重新登录)

mysql> SELECT @@tx_isolation;
+----------------+
| @@tx_isolation |
+----------------+
| SERIALIZABLE   |
+----------------+
1 row in set (0.00 sec)

mysql> select * from test.user;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

[窗口A]:

mysql> commit;
Query OK, 0 rows affected (0.01 sec)

[窗口B]:

mysql> mysql> select * from test.user;
+----+------+
| id | name |
+----+------+
|  2 | b    |
|  4 | d    |
|  5 | e    |
+----+------+
3 rows in set (0.00 sec)Thank ~

来源：http://mp.weixin.qq.com/s?__biz=MjM5NDM4MDIwNw==&mid=2448834642&idx=1&sn=c02c5cc8ab0c1f29142ac8f8aa6b78af#rd

更多【干货分享】，请关注我的个人订阅号。
Mysql 事务的四种隔离级别

mysql 事宜的四种隔离级别

mysql 事务的四种隔离级别 !--[if !mso] style v\:* {behavior:url(#default#VML);} o\:* {behavior:url(#default#VML);} w\:* {behavior:url(#default#VML);} .shape {behavior:url(#default#VML);} /style ![endif]-- ? 我们知道事务有四种特性 ? （ 1 ）原

mysql 事务的四种隔离级别

我们知道事务有四种特性

（1）原子性：一个事务被视为不可分割的一个单位

（2）隔离性：事务之间隔离开来，一个事务所做的修改，未提交之前另一个事务是不可见的

（3）永久性：事务的更改是永久的

（4）一致性：数据库总是从一个一致性的状态转换到另外一个一致性的状态中

在此之前，我们来学习一下mysql 如何设置隔离级别

SELECT@@global.tx_isolation;

SELECT@@session.tx_isolation;

SELECT@@tx_isolation;

set tx_isolation = ''read-uncommited'';设置默认隔离级别

1、默认：下一个事务开始

2、session：当前链接

3、global：从此开始，全局都是

隔离级别：

（1）Read Uncommited（读未提交）：发生脏读

?客户端A

开始状态：

?
?

客户端B

?

?

2、客户端A开始事务，但是没有提交，客户端B可以看到

1）、客户端A的状态：

?
?

客户端B的状态：

?
?

2）开始事务，并在客户端改变值

?
?

3）这时候查看客户端B，可以看到变化，这就是脏读现象

?
?

（2）Read Committed （读提交）：容易发生“不可重复读”

1、首先先改变两边的状态

客户端A：

?
?

客户端B：

?
?

2、客户端A开始事务，客户端B也开始事务

?
?

3、这时候A更新一条记录，并且提交完毕，B未提交事务，又读了一次，这时候，两次读的数据不一致，导致了不可重复读

客户端A

?
?

客户端B：

?
?
?

简单的来说

客户端A	客户端B
事务开始	事务开始
?	读字段name为lin
更新字段name=qin	?
提交事务	?
?	读字段name为qin，两次读都不一致
?	提交事务

（3）Repeatable Read（可重复读）：幻读现象

简单的用表格表示下：

客户端A	客户端B
事务开始	事务开始
读name=lin	?
?	更新name=qin
?	Commit提交事务
读name还是为lin	事务2开始
?	插入一条数据
?	?
?	?

1、???????? 改变事务隔离级别

?
?
?

2、???? 客户端B改变并且提交

?
?
?

3、???? 客户端A两次读都未发生不可重复读现象

?
?

4、???????? 客户端B插入一条记录（还未提交）

?
?

5、???????? 查看客户端A未发生变化，这时候客户端B提交

?
?

6、???????? 再次查看客户端A的数据，还是没有发生任何问题

所以mysql到了repeatable read级别之后，没有出现任何问题

这是因为innoDB存储引擎通过MVCC（多版本控制）解决了幻读的问题。

mysql 四种隔离级别

事务的四个特征（ACID）

事务具有四个特征：原子性（ Atomicity ）、一致性（ Consistency ）、隔离性（ Isolation ）和持续性（ Durability ）。这四个特性简称为 ACID 特性。

1 、原子性。事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做

Mysql的四种隔离级别

SQL标准定义了4类隔离级别，包括了一些具体规则，用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。

Read Uncommitted（读取未提交内容）

Read Committed（读取提交内容）

这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。

Repeatable Read（可重读）

这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读（Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。

Serializable（可串行化）

出现问题

这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：

不可重复读(Non-repeatable read):在一个事务的两次查询之中数据不一致，这可能是两次查询过程中间插入了一个事务更新的原有的数据。

幻读(Phantom Read):在一个事务的两次查询中数据笔数不一致，例如有一个事务查询了几列(Row)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。

在MySQL中，实现了这四种隔离级别，分别有可能产生问题如下所示：

测试Mysql的隔离级别

下面，将利用MySQL的客户端程序，我们分别来测试一下这几种隔离级别。

测试数据库为demo，表为test；表结构：

两个命令行客户端分别为A，B；不断改变A的隔离级别，在B端修改数据。

（一）、将A的隔离级别设置为read uncommitted(未提交读)

set session transaction isolation level read uncommitted;

查看隔离级别是否设置成功

select @@transaction_isolation （mysql版本 8.0 以后）

select @@tx_isolation （mysql版本 8.0 之前）

查看mysql版本

> status

A：启动事务，此时数据为初始状态

start transaction;

B：启动事务，更新数据，但不提交

start transaction;

A：再次读取数据，发现数据已经被修改了，这就是所谓的“脏读”

B：回滚事务

rollback;

A：再次读数据，发现数据变回初始状态

经过上面的实验可以得出结论，事务B更新了一条记录，但是没有提交，此时事务A可以查询出未提交记录。造成脏读现象。未提交读是最低的隔离级别。

（二）、将客户端A的事务隔离级别设置为read committed(已提交读)

set session transaction isolation level read committed;

A：启动事务，此时数据为初始状态

B：启动事务，更新数据，但不提交

A：再次读数据，发现数据未被修改

B：提交事务

A：再次读取数据，发现数据已发生变化，说明B提交的修改被事务中的A读到了，这就是所谓的“不可重复读”

(三)、将A的隔离级别设置为repeatable read(可重复读)

A：启动事务，此时数据为初始状态

B：启动事务，更新数据，但不提交

A：再次读取数据，发现数据未被修改

B：提交事务

A：再次读取数据，发现数据依然未发生变化，这说明这次可以重复读了

B：插入一条新的数据，并提交

A：再次读取数据，发现数据依然未发生变化，虽然可以重复读了，但是却发现读的不是最新数据，这就是所谓的“幻读”

A：提交本次事务，再次读取数据，发现读取正常了

(四)、将A的隔离级别设置为可串行化(Serializable)

A：启动事务，此时数据为初始状态

B：发现B此时进入了等待状态，原因是因为A的事务尚未提交，只能等待（此时，B可能会发生等待超时）

A：提交事务

B：发现插入成功

MySQL事务的四种隔离级别

事务的基本要素:

　　原子性(atomicity):事务开始后的全部操作, 要么全部执行成功,如果中间出现错误,事务回滚到事务开始前的状态.

　　一致性(Consistency):事务开始后,数据库的完整性约束没有被破坏.例如:A向B转账,A扣除了金额,B却没收到

　　隔离性(Isolation):同一时间,只允许一个事务请求同一数据,不同事务之间没有彼此没有干扰.

　　持久性(Durability):事务完成后,事务对数据库的所有更新都保留到数据库,不能进行回滚.

事务并发问题

　　脏读:事务A读取了事务B更新的数据, 事务B进行回滚.事务A读取到的数据就是脏数据

　　不可重复读取:事务A多次读取同一数据,事务B在事务A多次读取过程中,对数据多次更新并提交,导致事务A多次读取同一数据,结果不一致

　　幻读:系统管理员对数据库中的所有学生成绩从具体分数改变为ABCD等级,系统管理原B添加一条学生的具体分数.系统管理原A改完后发现还有一条数据没有改过来,就好像发生幻觉一样.

小结:

　　不可重复读取重于修改,取解决锁住满足条件的行.幻读重于插入和删除,解决锁住表

MySQL事务隔离级别

事务隔离级别 脏读 不可重复读取 幻读读取未提交(read-uncommitted) 是是是不可重复读取(read-committed) 否是是可重复读取(repeatable-read) 否否是串行化（serializable）否否否

mysql默认事务隔离级别为:可重复读取(reeatable-read)

spring中事务管理

　　事务抽象

　　提供了一致的事务模型(JDBC/Hibernate/mybatis/dataSource/JTA)

　　事务接口

　　PlatformTransactionManager

- - DataSourceTransactionManager
  - HibernateTransactionManager
  - JtaTransactionManager

　　事务相关方法

　　void commit(TransactionStatus status) throws TransactionException;

　　 void rollback(TransactionStatus status) throws TransactionException;

　　TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;

　　定义事务相关

　　　TransactionDefinition

　　　　　属性:

　　　　　Propagation(传播方式)

　　　　　Isolation(隔离)

　　　　　Timeout

　　　　 Read-only status (true or false) 　　　

　　　自定义事务:　

　　// 其中 dataSource 框架会自动为我们注入
　　@Bean(name = "MyTransaction")
　　public PlatformTransactionManager txManager(@Qualifier("MyDataSource") DataSource dataSource) {
  　　  return new DataSourceTransactionManager(dataSource);
　　}

　　传播特性

传播性 值描述 PROPAGATION_required 0 当前有事务就用, 没有事务就新建一个事务(默认) PROPAGATION_supports　 1 事务可有可无,不是必须的 PROPAGATION_mandatory　　 2 当前一定要有事务,不然就抛出异常　　　　 PROPAGATION_REQUIRED_NEW　　 3 无论是否有事务,都创建一个新事务　　　　 PROPAGEATION_NOT_SUPPORTS 4
不支持事务,按照非事务方式进行 PROPAGEATION_NAVER　　 5
不支持事务,如果有事务则抛出异常 PROPAGEATION_NESTED 6 当前有事务就在当前事务内在起一个事务,内部事务不影响外部事务

事务隔离特性

隔离性 值脏读 不可重复读取 幻读 ISOLATION_READ_UNCOMMITTED (未提交) 1 √ √ √ ISOLATION_READ_COMMITTED(不可重复读取) 2 × √ √ ISOLATION_REPEATABLE_READ(可重复读取) 3 × × √ ISOLATION_SERIAILZABLE(串行化) 4 × × ×

编程式事务

　可以使用transactionTeamplate,如果有返回值的可以使用TransactionCallback,没有返回值可以使用TransactionCallbackWithoutResult.

@SpringBootApplication
@Slf4j
public class ProgrammaticTransactionDemoApplication implements CommandLineRunner {
   @Autowired
   private TransactionTemplate transactionTemplate;
   // 如果没有配置数据源, spring boot 自动注入默认数据库DB2
   @Autowired
   private JdbcTemplate jdbcTemplate;

   public static void main(String[] args) {
      SpringApplication.run(ProgrammaticTransactionDemoApplication.class, args);
   }

   @Override
   public void run(String... args) throws Exception {
      log.info("事务开启前数据库数据数量 {}", getCount());
      // 执行事务
      transactionTemplate.execute(new TransactionCallbackWithoutResult() {
         @Override
         protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
            // jdbc执行sql语句
            jdbcTemplate.execute("INSERT INTO FOO (ID, BAR) VALUES (1, ''aaa'')");
            log.info("执行sql后数据库数据数量 {}", getCount());
            // 事务进行回滚
            transactionStatus.setRollbackOnly();
         }
      });

      log.info("事务回滚后数据库数据数量", getCount());
   }

   // 查询数据库数据数量
   private long getCount() {
      return (long) jdbcTemplate.queryForList("SELECT COUNT(*) AS CNT FROM FOO")
            .get(0).get("CNT");
   }
}

执行结果:
　　
事务开启前数据库数据数量 0
执行sql后数据库数据数量 1
事务回滚后数据库数据数量 0

声明式事务:

　　spring 声明式事务式事务是利用AOP的proxy,在目标方法上进行封装,帮助用户进行模板式事务操作

基于注解的配置

　　开启事务的方式:

　　　　添加@EnableTransactionManagement注解:

　　　　参数

　　　　proxyTargetClass (代理目标类)

　　　　　　proxyTargetClass 值说明:　　　

@EnableTransactionManagement(proxyTargetClass = true) //使用CGLIB代理方式增强

- - - 没有定义接口只有实现方法时都思源CGLIB进行代理(增强方法)　　　
    - 有定义接口,并实现接口
      - true: 使用CGLIB进行代理
      - false:使用JDK动态代理机制(代理所有实现了的接口)

　　　　　　model: 默认使用 @EnableTransactionManagement(mode = AdviceMode.PROXY).

　　　　　　order:指定事务AOP拦截顺序,默认时最低优先级,保证所有的事务在启动后都可以执行

　　@Transactional的使用

- - 属性
    - transactionManager 指定事务　实例:@Transactional(transactionManager = "MyTransaction")
    - propagation 传播特性
    - isolation 隔离机制
    - timeout 超时
    - readOnly 是否只读
    - 怎么判断回滚, 碰到特定异常的时候进行回滚,示例:@Transactional(rollbackFor=RollbackException.class)

我们今天的关于深入理解Mysql的四种隔离级别和深入理解mysql的四种隔离级别是什么的分享就到这里，谢谢您的阅读，如果想了解更多关于Mysql 事务的四种隔离级别、mysql 事宜的四种隔离级别、mysql 四种隔离级别、MySQL事务的四种隔离级别的相关信息，可以在本站进行搜索。

本文标签：