Spring事务和事务传播、隔离

女爷i 2022-12-07 04:24 202阅读 0赞

# **一 事务** #

事务是一组操作的执行单元，针对数据库操作，事务管理的是一组SQL指令，事务内的操作要不全部成功，要不全部失败。比如执行过程中，如果有一条SQL语句没有执行成功，那么这一组操作都将全部回滚

事务特性（ACID）： (默写)

Atomic(原子性):要么都成功，要么都失败

Consistent(一致性):数据不应该被破坏

Isolate(隔离性):用户间操作不相混淆

Durable(持久性):永久保存

## **1 编程式事务** ##

编程式的事务，可以实现细粒度的事务控制，比如可以控制事务何时开始，何时结束等，但是spring中一般不提倡使用。Spring提供两种方式的编程式事务管理，分别是使用TransactionTemplate和直接使用PlatformTransactionManager。

## **2 声明式事务** ##

在Spring中使用AOP思想，对目标方法动态织入事务处理操作，根据目标方法执行情况，提交或者回滚。在Spring中，只需要在配置文件中进行一系列配置（或者通过@Transactional注解），即可将相关方法纳入到事务管理中，这种做法降低了代码的耦合度，灵活方便。

Try\{

数据库的操作

Comit()

\}catch(Exception e)\{

Rollback()

\}finally\{

Close()

Spring使用声明式事务，结合AOP一起使用

Spring中的事务针对方法，一般将事务用在service层

# **二 事务配置** #

## **1 引入jar包** ##

需要导入AOP相关jar文件，

还需要导入spring-tx-5.1.5.RELEASE.jar

## **2 引入名称空间** ##

<beans xmlns=*"http://www.springframework.org/schema/beans"*

xmlns:xsi=*"http://www.w3.org/2001/XMLSchema-instance"*

xmlns:context=*"http://www.springframework.org/schema/context"*

xmlns:aop=*"http://www.springframework.org/schema/aop"*

xmlns:tx=*"http://www.springframework.org/schema/tx"*

xsi:schemaLocation=*"http://www.springframework.org/schema/beans*

*        http://www.springframework.org/schema/beans/spring-beans.xsd*

*        http://www.springframework.org/schema/context*

*        http://www.springframework.org/schema/context/spring-context.xsd*

*        http://www.springframework.org/schema/aop*

*        http://www.springframework.org/schema/aop/spring-aop.xsd*

*        **http://www.springframework.org/schema/tx*

*        http://www.springframework.org/schema/tx/spring-tx.xsd**"*>

## **3 xml方式事务的配置** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDg1MDQ_size_16_color_FFFFFF_t_70][]

<bean id=*"txManage"* class=*"org.springframework.jdbc.datasource.DataSourceTransactionManager"*>

<property name=*"dataSource"* ref=*"dataSource"*></property>

</bean>

<tx:advice id=*"txAdvice"* transaction-manager=*"txManage"*>

<tx:attributes>

<!-- 针对使用事务的add开头的方法

read-only 是否只读，true 是，false 可读可写

如果有插入等操作，设为为true，运行程序会报异常-->

<tx:method name=*"get**\***"* read-only=*"**true**"** *propagation=*"**SUPPORTS**"*/>

<tx:method name=*"add\*"* read-only=*"false"** *propagation=*"**REQUIRED**"*/>

<tx:method name=*"\*"** *propagation=*"**NOT\_SUPPORTED**"*/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression=*"execution(\* com.rr.xml.PersonService.\*(..))"* id=*"pc"*/>

<aop:advisor advice-ref=*"txAdvice"* pointcut-ref=*"pc"*/>

</aop:config>

## **4 注解方式** ##

@Transactional 既可以修饰方法，也可以修饰类

//rollbackFor=Exception.class

//rollbackFor 表示哪些异常回滚

//noRollbackFor 表示某些异常下不回滚

//声明事务的注解

@Transactional(readOnly=**false**,//是否只读，如果只有查询，设置为true，效率高

propagation=Propagation.***REQUIRED***, //事务的传播特性

isolation=Isolation.***DEFAULT***, //事务的隔离特性

timeout=3,//事务的超时时间，单位秒，默认-1

noRollbackFor=ArithmeticException.**class** //回滚规则

)

**public** **void** addPerson(String name)\{ \}

<bean id=*"txManage"* class=*"org.springframework.jdbc.datasource.DataSourceTransactionManager"*>

<property name=*"dataSource"* ref=*"dataSource"*></property>

</bean>

<tx:annotation-driven transaction-manager=*"txManage"*/>

事务的传播特性：多个事务方法相互调用时，事务如何在这些方法间传播

<table style="margin-left:-1.8pt;width:425.4pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> 传播特性 </td> 
 <td style="vertical-align:top;width:334.45pt;"> 意义 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> REQUIRED </td> 
 <td style="vertical-align:top;width:334.45pt;"> 常用默认配置。业务方法运行时会开启事务。如果方法运行时，已经处在一个事务中，进行事务的合并 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> NOT_SUPPORTED </td> 
 <td style="vertical-align:top;width:334.45pt;"> 声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> REQUIRES_NEW&nbsp; </td> 
 <td style="vertical-align:top;width:334.45pt;"> 不管是否存在事务，业务方法总会开启一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> MANDATORY </td> 
 <td style="vertical-align:top;width:334.45pt;"> 业务方法只能在一个已经存在的事务中执行。如果业务方法在没有事务的环境下调用，容器就会抛出例外。 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> SUPPORTS </td> 
 <td style="vertical-align:top;width:334.45pt;"> 如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> Never </td> 
 <td style="vertical-align:top;width:334.45pt;"> 指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出异常，只有业务方法没有关联到任何事务，才能正常执行 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:90.95pt;"> NESTED </td> 
 <td style="vertical-align:top;width:334.45pt;"> 如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务， 这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效 </td> 
 </tr> 
 </tbody> 
</table>

事务的隔离级别：用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。

<table style="margin-left:-1.8pt;width:432.45pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:92.25pt;"> 隔离级别 </td> 
 <td style="vertical-align:top;width:340.2pt;"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:92.25pt;"> DEFAULT </td> 
 <td style="vertical-align:top;width:340.2pt;"> 使用后端数据库默认的隔离级别(spring中的的选择项) </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:92.25pt;"> READ_UNCOMMITED </td> 
 <td style="vertical-align:top;width:340.2pt;"> 允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:92.25pt;"> READ_COMMITTED </td> 
 <td style="vertical-align:top;width:340.2pt;"> 允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:92.25pt;"> REPEATABLE_READ </td> 
 <td style="vertical-align:top;width:340.2pt;"> 对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:92.25pt;"> SERIALIZABLE </td> 
 <td style="vertical-align:top;width:340.2pt;"> 完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。&nbsp; </td> 
 </tr> 
 </tbody> 
</table>

什么是脏数据，脏读，不可重复读，幻觉读？

1）脏读: 指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据， 那么另外一个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的。

2）不可重复读: 指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

3）幻觉读: 指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

mysql默认的事务处理级别是'REPEATABLE-READ',也就是可重复读

查看当前会话隔离级别

select @@tx\_isolation;

查看系统当前隔离级别

select @@global.tx\_isolation;

# 一、[事务传播机制][Link 1]：   **事务的传播行为是针对嵌套事务而言。** #

**示例：**

@Transactional(propagation = Propagation.REQUIRED)

### 2.1.1 **REQUIRED** ###

spring**默认的事务传播行为**就是它。

支持事务。如果业务方法执行时已经在一个事务中，则加入当前事务，否则重新开启一个事务。

外层事务提交了，内层才会提交。

内/外只要有报错，他俩会一起回滚。

**只要内层方法报错抛出异常，即使外层有try-catch，该事务也会回滚！**

**因为内外层方法在同一个事务中，内层只要抛出了异常，这个事务就会被设置成rollback-only，即使外层try-catch内层的异常，该事务也会回滚。**

**例子：**

外层方法在调用内层方法的时候包裹住try-catch，内层方法报错抛出异常。

外层方法：

1.  `@Service`
2.  `public class UserServiceImp implements UserService {`
3.   
4.  `@Resource`
5.  `private UserMapper userMapper;`
6.   
7.  `@Autowired`
8.  `StudentService studentService;`
9.   
10. `@Override`
11. `@Transactional`
12. `public int addUser(User user) {`
13. `int i = userMapper.insertSelective(user);`
14. `Student student = new Student();`
15. `student.setCourse("cs");`
16. `student.setName("sid");`
17. `try {`
18. `studentService.addStudent(student);`
19. `}catch (Exception e){`
20. `//不抛出`
21. `}`
22. `return i;`
23. `}`
24. `}`

内层方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional//(propagation = Propagation.NESTED)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `int j = 10/ 0; // 内层报错抛出异常`
12. `return i;`
13. `}`
14. `}`

**结果：**

事务回滚，user表和student表都没有插入数据。

**因为内外层方法在同一个事务中，内层只要抛出了异常，这个事务就会被设置成rollback-only，即使外层try-catch内层的异常，该事务也会回滚。**

报错

org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only

### 2.1.2 **REQUIRES\_NEW** ###

**支持事务。每次都是创建一个新事物，如果当前已经在事务中了，会挂起当前事务。**

**内层事务结束，内层就提交了，不用等着外层一起提交。**

**外层报错回滚，不影响内层。**

**内层报错回滚，外层try-catch内层的异常，外层不会回滚。**

**内层报错回滚，然后又会抛出异常，外层如果没有捕获处理内层抛出来的这个异常，外层还是会回滚的。这是重点！！！网上有些文章的例子给错了！！！**

**例子：**

**1.调用addStudent的外层方法有事务，外层报错回滚，内层无错**

外层方法：

内层方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.REQUIRES_NEW)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11.  
12. `return i;`
13. `}`
14. `}`

**结果：**

内层的addStudent方法执行结束后，这个内层的事务就提交了，student表中就已经插入了数据了。

外层addUser方法报错，只是回滚了外层的这个事务，user表中没有插入数据。

**2.调用addStudent的外层方法有事务，外层无错，内****层报错回滚**

外层方法：

内层方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.REQUIRES_NEW)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `int j = 10/ 0;`
12. `return i;`
13. `}`
14. `}`

**结果：**

内层的addStudent方法执行报错 ，内层事务回滚，然后再向外抛出这个异常。student表中没有插入数据。

外层addUser，如果没有捕获处理内层抛出来的异常，外层一会回滚。user表中没有插入数据。

### 2.1.3 **NESTED：** ###

**该传播行为解释：支持事务。如果当前已经在一个事务中了，则嵌套在已有的事务中作为一个子事务。如果当前没在事务中则开启一个事务。**

**内层事务结束，要等着外层一起提交。**

**外层回滚，内层也回滚。**

**如果只是内层回滚，不影响外层。**

**这个内层回滚不影响外层的特性是有前提的，否则内外都回滚。**

**使用前提：**

> 1.JDK版本要在1.4以上，有java.sql.Savepoint。因为nested就是用savepoint来实现的。
> 
> 2.事务管理器的nestedTransactionAllowed属性为true。
> 
> 3.**外层try-catch内层的异常。**

**例子：**

**1.调用addStudent的外层方法有事务，外层报错回滚，内层无错**

外层调用方法：

内层调用方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.NESTED)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `return i;`
12. `}`
13. `}`

**结果：**

studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。而此时，外层报错了，回滚，student表和user表都无数据插入。

**2.调用addStudent的外层方法有事务，外层无错，内****层报错回滚**

外层调用方法：

1.  `@Service`
2.  `public class UserServiceImp implements UserService {`
3.   
4.  `@Resource`
5.  `private UserMapper userMapper;`
6.   
7.  `@Autowired`
8.  `StudentService studentService;`
9.   
10. `@Override`
11. `@Transactional`
12. `public int addUser(User user) {`
13. `int i = userMapper.insertSelective(user);`
14. `Student student = new Student();`
15. `student.setCourse("cs");`
16. `student.setName("sid");`
17. `// 强调一下，内层是nested模式下，外层要try-catch内层的异常，外层才不会回滚`
18. `// 而内层是REQUIRED模式的话，即是外层try-catch内层异常，外层同样会回滚的`
19. `try {`
20. `studentService.addStudent(student);`
21. `}catch (Exception e){`
22. `//不抛出`
23. `}`
24. `return i;`
25. `}`
26. `}`

内层调用方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.NESTED)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `int j = 10/ 0; // 内层报错`
12. `return i;`
13. `}`
14. `}`

**结果：**

studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。而此时，自己内层报错了回滚，并不影响外层addUser方法的事务。 student表无数据插入。User表数据插入成功。

**强调一下：**

**内层是nested模式下，外层要try-catch内层的异常，外层才不会回滚  
而内层是****REQUIRED模式的话，即是外层try-catch内层异常，外层同样会回滚的**

### 2.1.4.SUPPORTS： ###

**该传播行为解释：支持事务。当前有事务就支持。当前没有事务就算了，不会开启一个事物。**

**例子：**

**1.直接从外面调这个addStudent方法**，外面没有事务，这个addStudent方法的事务传播行为是SUPPORTS。

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.SUPPORTS)// 这个addStudent方法的事务传播行为是SUPPORTS。`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `return i;`
12. `}`
13. `}`

**结果：**

此时相当于addStudent方法没有事务。执行了insertSelective后，数据就已经插入到Mysql对应的student表中了。

等于说@Transactional(propagation = Propagation.SUPPORTS)修饰的方法本身是没有事务性的。

**2.调用addStudent的外层方法有事务**

外层调用方法：

1.  `@Service`
2.  `public class UserServiceImp implements UserService {`
3.   
4.  `@Resource`
5.  `private UserMapper userMapper;`
6.   
7.  `@Autowired`
8.  `StudentService studentService;`
9.   
10. `@Override`
11. `@Transactional //有事务`
12. `public int addUser(User user) {`
13. `int i = userMapper.insertSelective(user);`
14. `Student student = new Student();`
15. `student.setCourse("cs");`
16. `student.setName("sid");`
17. `studentService.addStudent(student);// 调用addStudent方法，addStudent方法的事务传播机制是SUPPORTS`
18. `return i;`
19. `}`
20.  
21. `}`

内层传播机制为SUPPORTS的方法：强调，外层方法和内层方法不在同一个类中

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.SUPPORTS) // 这个addStudent方法的事务传播行为是SUPPORTS`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `return i;`
12. `}`
13. `}`

**结果：**

studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。

### 2.1.5.**MANDATORY** ###

**该传播行为解释：支持事务，如果业务方法执行时已经在一个事务中，则加入当前事务。否则抛出异常。**

**例子：**

**1.直接从外面调这个addStudent方法**，外面没有事务

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.MANDATORY)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `return i;`
12. `}`
13. `}`

**结果：抛出异常**

org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

**2.调用addStudent的外层方法有事务**

外层调用方法：

内层方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.MANDATORY)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `return i;`
12. `}`
13. `}`

**结果：**

studentMapper.insertSelective(student);方法执行后，数据库student表中并没有插入数据，要等到外层addUser方法的事务结束后，才一起提交。

### **2.1.6.NOT\_SUPPORTED** ###

**不支持事务，如果业务方法执行时已经在一个事务中，则挂起当前事务，等方法执行完毕后，事务恢复进行。**

**例子：**

**1.调用addStudent的外层方法有事务**

外层调用方法：

内层调用方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.NOT_SUPPORTED)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11. `return i;`
12. `}`
13. `}`

**结果：**

studentMapper.insertSelective(student);方法执行后，数据库student表中已经插入了数据，不用等到**自己**的addStudent方法的事务结束后才提交。

### **2.1.7.NEVER** ###

**不支持事务。如果当前已经在一个事务中了，抛出异常。**

**例子：**

**1.调用addStudent的外层方法有事务**

外层调用方法：

内层调用方法：

1.  `@Service`
2.  `public class StudentServiceImp implements StudentService {`
3.   
4.  `@Resource`
5.  `private StudentMapper studentMapper;`
6.   
7.  `@Override`
8.  `@Transactional(propagation = Propagation.NEVER)`
9.  `public int addStudent(Student student) {`
10. `int i = studentMapper.insertSelective(student);`
11.  
12. `return i;`
13. `}`
14. `}`

**结果：**

外层addUser方法在调内层方法addStudent的时候，因为内层方法不支持事务，而外层方法开启了事务，则报错

org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'

# 二、事务的隔离机制 #

## 2.1事务隔离级别 ##

**1.DEFAULT** ,**这是spring默认的隔离级别**，表示使用数据库默认的事务隔离级别。另外四个与JDBC的隔离级别相对应。

**2.READ\_UNCOMMITTED** 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻读。

**3.READ\_COMMITTED** 保证一个事务修改的数据提交后才能被另外一个事务读取。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻读。

**4.REPEATABLE\_READ**这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻读。

**5.SERIALIZABLE** 事务被处理为顺序执行。防止脏读，不可重复读，防止幻读。

**示例：**

@Transactional(isolation=Isolation.REPEATABLE\_READ)

**Mysql innodb默认提供的是REPEATABLE\_READ**

## 2.2脏读、不可重复读、幻读解释： ##

**1.脏读:脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。**

> 1.  Mary的原工资为1000,财务人员将Mary的工资改为了8000，但未提交事务
> 2.  与此同时，Mary正在读取自己的工资.Mary发现自己的工资变为了8000，欢天喜地！ （脏读）
> 3.  而财务发现操作有误，而回滚了事务,Mary的工资又变为了1000.

**2.不可重复读**:**在一个事务中前后两次读取的结果并不致，导致了不可重复读。**

> 1.  在事务1中，Mary 读取了自己的工资为1000,操作并没有完成 .
> 2.  在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.
> 3.  在事务1中，Mary 再次读取自己的工资时，工资变为了2000.

**3.幻读：第一个事务对一个表中的全部数据行进行了修改。同时，第二个事务向表中插入一行新数据。那么操作第一个事务的用户发现表中还有未修改的数据行。**

目前工资为1000的员工有10人。

> 1.  事务1,读取所有工资为1000的员工。
> 2.  这时事务2向employee表插入了一条员工记录，工资也为1000
> 3.  事务1再次读取所有工资为1000的员工 共读取到了11条记录

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDg1MDQ_size_16_color_FFFFFF_t_70]: /images/20221123/1c819e7d219d4f24878aa87b8e84a4d7.png
[Link 1]: https://blog.csdn.net/jy02268879/article/details/84322459