数据库之【事务特性】和【隔离级别】和【传播行为】

最新推荐文章于 2022-03-08 14:21:53 发布

EasyChill

最新推荐文章于 2022-03-08 14:21:53 发布

阅读量305

点赞数

分类专栏：数据库

本文链接：https://blog.csdn.net/Song_JiangTao/article/details/82623025

版权

数据库专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1、事务的四大特性
2、多个事务访问同一数据遇到的五类问题
3、隔离级别
4、传播行为
5、Java代码中的事务配置

1、事务的四大特性

原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；
一致性(Consistent)：事务结束后系统状态是一致的；
隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；
持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后重建数据。

这就是人们常说的ACID

2、多个事务访问同一数据遇到的五类问题

需要明确的是：

$\color{red}{只有存在并发数据访问时才需要事务}$

当多个事务访问同一数据时，可能会存在5类问题，包括3类数据读取问题（脏读、不可重复读和幻读）和2类数据更新问题（第1类丢失更新和第2类丢失更新）

1、脏读（Dirty Read）：A事务读取B事务尚未提交的数据并在此基础上操作，而B事务执行回滚，那么A读取到的数据就是脏数据。

例如：银行存取款案例（下同）：事务B和事务A相继开启，事务B查询余额剩余1000并取款500，剩余500，此时事务A查询余额（脏读），并存款100，剩600，然后呢，B撤销事务。A就属于脏读

时间	转账事务A	取款事务B
T1		开始事务
T2	开始事务
T3		查询账户余额为1000元
T4		取出500元余额修改为500元
T5	查询账户余额为500元（脏读）
T6		撤销事务余额恢复为1000元
T7	汇入100元把余额修改为600元
T8	提交事务

2、 不可重复读（Unrepeatable Read）：事务A重新读取前面读取过的数据，发现该数据已经被另一个已提交的事务B修改过了。不可重复度重点在于修改，这是不可重复读与幻读的区别

例如：事务AB相继开启，事务B查询余额剩余1000，事务A查询余额并取走100，并提交事务，此时事务B再次查询剩900，B什么也没干，就少钱了。

时间转账事务A 取款事务B
T1 开始事务
T2 开始事务
T3 查询账户余额为1000元
T4 查询余额剩余1000
T5 取走100剩余900
T6 提交事务
T7 查询账户余额为900元（不可重复读）
3、幻读（Phantom Read）：事务A重新执行一个查询，返回一系列符合查询条件的行，发现其中插入了被事务B提交的行。幻读又称虚读，幻读的重点在于新增和删除，这是幻读与不可重复读的区别

例如：事务AB相继开启，事务A查询余额剩余1000，事务B存款100，提交事务，事务A再次读取余额剩余1100

时间统计金额事务A 转账事务B
T1 开始事务
T2 开始事务
T3 统计总存款为1000元
T4 新增一个存款账户存入100元
T5 提交事务
T6 再次统计总存款为1100元（幻读）

4、 第1类丢失更新：事务A撤销时，把已经提交的事务B的更新数据覆盖了。

例如：事务AB相继开启，事务A查询余额剩1000，事务B查询余额剩余1000并存款100，剩1100，提交事务B，事务A取款100剩余900，撤销事务以后，剩1000，实际有1100（丢失更新）

时间	取款事务A	转账事务B
T1		开始事务
T2	开始事务
T3	查询账户余额为1000元
T4		查询账户余额为1000元
T5		汇入100元修改余额为1100元
T6		提交事务
T7	取出100元将余额修改为900元
T8	撤销事务
T9	余额恢复为1000元（丢失更新）

5、 第2类丢失更新：事务A覆盖事务B已经提交的数据，造成事务B所做的操作丢失。

例如：事务AB相继开启，事务A查询余额剩1000，事务B查询余额剩余1000并取款100，剩900，提交事务B，事务A此时存款100，查询剩余1100（丢失更新）

时间	转账事务A	取款事务B
T1	开始事务
T2		开始事务
T3	查询账户余额为1000元
T4		查询账户余额为1000元
T5		取出100元将余额修改为900元
T6		提交事务
T7	汇入100元将余额修改为1100元
T8	提交事务
T9	查询账户余额为1100元（丢失更新）

3、隔离级别

现在来看看MySQL数据库为我们提供的四种隔离级别：

　　① Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。

　　② Repeatable read (可重复读)：可避免脏读、不可重复读的发生。

　　③ Read committed (读已提交)：可避免脏读的发生。

　　④ Read uncommitted (读未提交)：最低级别，任何情况都无法保证。

　　以上四种隔离级别最高的是Serializable级别，最低的是Read uncommitted级别，当然级别越高，执行效率就越低。像Serializable这样的级别，就是以锁表的方式(类似于Java多线程中的锁)使得其他的线程只能在锁外等待，所以平时选用何种隔离级别应该根据实际情况。在MySQL数据库中默认的隔离级别为Repeatable read (可重复读)。可使用select @@tx_isolation;查看，使用set tx_isolation='隔离级别名称';设置，这两个操作均在命令行可执行，在这之前需要登陆MySQL，选择好数据库。

　　在MySQL数据库中，支持上面四种隔离级别，默认的为Repeatable read (可重复读)；而在Oracle数据库中，只支持Serializable (串行化)级别和Read committed (读已提交)这两种级别，其中默认的为Read committed级别。
　　设置数据库的隔离级别一定要是在开启事务之前！

4、传播行为

传播行为内容转自:
https://blog.csdn.net/wwh578867817/article/details/51736723

下面的配置中，使用了隔离级别和传播行为的概念，这里介绍Spring中的七种传播行为。
Propagation ：
　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：

PROPAGATION_REQUIRED
- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  
  详细解释：加入当前正要执行的事务不在另外一个事务里，那么就起一个新的事务。
  
  比如说 ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候，ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA的事务内部，就不再起新的事务。
  
  而假如ServiceA.methodA运行的时候发现自己没有在事务中，他就会为自己分配一个事务。
  
  这样，在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常，事务都会被回滚。即使ServiceB.methodB的事务已经被提交，但是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB也要回滚
PROPAGATION_SUPPORTS
- 支持当前事务，如果当前没有事务，就以非事务方式执行。
  
  详细解释：如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行
  
  这就跟平常用的普通非事务的代码只有一点点区别了。不理这个，因为我也没有觉得有什么区别
PROPAGATION_MANDATORY
- 支持当前事务，如果当前没有事务，就抛出异常。
  
  详细解释：必须在一个事务中运行。也就是说，他只能被一个父事务调用。否则，他就要抛出异常。
PROPAGATION_REQUIRES_NEW
- 新建事务，如果当前存在事务，把当前事务挂起。
  
  详细解释：这个就比较绕口了。比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW，
  
  那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，他才继续执行。
  
  他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。
  
  如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚，
  
  如果他抛出的异常被ServiceA.methodA捕获，ServiceA.methodA事务仍然可能提交。
PROPAGATION_NOT_SUPPORTED
- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  
  详细解释：当前不支持事务。比如ServiceA.methodA的事务级别是PROPAGATION_REQUIRED ，而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED ，
  
  那么当执行到ServiceB.methodB时，ServiceA.methodA的事务挂起，而他以非事务的状态运行完，再继续ServiceA.methodA的事务。
PROPAGATION_NEVER
- 以非事务方式执行，如果当前存在事务，则抛出异常。
  
  详细解释：不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED，而ServiceB.methodB的事务级别是PROPAGATION_NEVER ，那么ServiceB.methodB就要抛出异常了。
PROPAGATION_NESTED
- 如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。
  
  详细解释：理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是，
  
  PROPAGATION_REQUIRES_NEW另起一个事务，将会与他的父事务相互独立，而Nested的事务和他的父事务是相依的，他的提交是要等和他的父事务一块提交的。
  
  也就是说，如果父事务最后回滚，他也要回滚的。
  
  而Nested事务的好处是他有一个savepoint。也就是说ServiceB.methodB失败回滚，那么ServiceA.methodA也会回滚到savepoint点上，ServiceA.methodA可以选择另外一个分支，
  
  比如ServiceC.methodC，继续执行，来尝试完成自己的事务。

5、Java代码中的事务配置

jdbc中
Connection提供了事务处理的方法，通过调用setAutoCommit(false)可以设置手动提交事务；当事务完成后用commit()显式提交事务；如果在事务处理过程中发生异常则通过rollback()进行事务回滚。除此之外，从JDBC 3.0中还引入了Savepoint（保存点）的概念，允许通过代码设置保存点并让事务回滚到指定的保存点。

调用Connection对象的setTransactionIsolation(level)即可设置当前链接的隔离级别，至于参数level，可以使用Connection对象的字段

再调用此方法设置提交模式：
```
conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE );
conn.setAutoCommit(false);//手动提交事务
```

spring+mybatis中
1、xml配置文件的命名空间的引用,就是那一大堆http

2、配置事务管理类并开启事务行为

3、配置通知项

4、事务配合AOP

完整配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    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/aop   
        http://www.springframework.org/schema/aop/spring-aop-2.5.xsd 
         http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/tx    
            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd" >   

    <context:component-scan base-package="jdbc" >
     </context:component-scan>

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
        </bean>
        <!-- 配置的事务管理 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 匹配到类下方法的切入点, 比如 query* 表示匹配所有以 query开头的方法 , 这里可以配置事务行为 传播行为propagation, 隔离级别isolation， 超时(秒)timeout_xx, 自读read-only 等 -->
            <tx:method name="zhuan*" isolation="DEFAULT" propagation="REQUIRED" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut expression="execution(* jdbc.service.impl.AccountXmlServiceImpl.*(..))"  id="pointcut" />
        <aop:advisor advice-ref="txAdvice"  pointcut-ref="pointcut"/>
    </aop:config>
</beans>

5、测试使用

package jdbc.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import jdbc.dao.AccountDao;
import jdbc.service.AccountAnnotationService;
import jdbc.service.AccountService;
import jdbc.service.AccountXmlService;

@Service
public class AccountAnnotationServiceImpl implements AccountAnnotationService {

    @Autowired
    public AccountDao accountDao;

    @Override
    @Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT)
    public void zhuanzhang(String accountOut, String accountIn, int money) {
        // TODO Auto-generated method stub
        accountDao.accountOut(accountOut, money);
//      accountDao.accountInt(accountIn, money);
        this.zhuanru(accountIn, money);

    }
    @Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT)
    public void zhuanru(String accountIn, int money) {
        int a = 1/0;//设置异常测试事务
        accountDao.accountInt(accountIn, money);
    }

}

@Transactional注解:
（1）放在类名称上，这样你配置的这个@Transactional 对这个类中的所有public方法都起作用
（2）@Transactional 方法方法名上，只对这个方法有作用，同样必须是public的方法
（3）@Transactional和AOP实现的作用是一样的可以只取其一

我们在使用Spring声明式事务时，有一个非常重要的概念就是事务的属性。事务属性通常由事务的传播行为propagation, 事务隔离级别isolation等,在这里也可以进行配置.

说明:上面的业务层代码中,AccountDao接口中有两个方法,转入,转帐,dao中封装了和持久层交互的代码,测试类中只需要获取bean,然后调用方法即可,如下

package jdbc;

import org.junit.Test;

import common.UnitTestBase;
import jdbc.service.AccountService;
import jdbc.service.AccountXmlService;

public class JdbcXmlTest  extends UnitTestBase {

    public JdbcXmlTest() {
        super("spring-xml-jdbc.xml");
    }

    @Test
    public void test() {
        AccountXmlService service = getBean("accountXmlServiceImpl");
        service.zhuanzhang("sun", "jim", 100);
    }
}

EasyChill

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数据库之【事务特性】和【隔离级别】和【传播行为】

1、事务的四大特性2、多个事务访问同一数据遇到的五类问题3、隔离级别4、传播行为5、Java代码中的事务配置1、事务的四大特性原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；一致性(Consistent)：事务结束后系统状态是一致的；隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态； ...
复制链接

扫一扫

专栏目录