精华内容
下载资源
问答
  • 事务

    2016-08-04 23:10:00
    2、事务执行的结果是从个一致性状态变为另一一致性状态。事务执行完成后,事务处于个一致性状态,若执行中途发生故障,事务被迫中断,这时称数据库处于不一致状态。 3、事务的执行不能被其他事务打扰...

    一、事务

    事务就是一件事情。

    1、事务是一个整体,要么做完,要么一点不做,即具有原子性

    2、事务执行的结果是从一个一致性状态变为另一一致性状态。事务执行完成后,事务处于一个一致性状态,若执行中途发生故障,事务被迫中断,这时称数据库处于不一致状态

    3、一个事务的执行不能被其他事务打扰。事务隔离级别(Transaction Isolation Level)如下:

        READ_UNCOMMITTED;

        READ_COMMITTED;

        REPEATABLE_READ;

        SERIALIZABLE;

            

    4、持续性也称持久性,即一个事务提交后对数据库的改变是永久性的,后面的其他操作不应对其执行结果产生影响,比如事务A对数据库进行了操作,然后事务B做了其他操作,事务B的结果只能影响数据库,而不应该影响事务A的结果,不能因为B而使A的结果产生变化。

    原子性是基础,隔离性是手段,持久性是目的。

     

    二、数据在高并发下的问题

    1、Dirty Read

    事务A读取了事务B未提交的数据,并在其基础上又做了其他操作。

    2、Unrepeatable Read

    事务A读取了事务B已提交的更改数据。

    3、Phantom Read

    事务A读取了事务B已提交的新增数据。

    转载于:https://my.oschina.net/LinuxDaxingxing/blog/727547

    展开全文
  • -致性:总数不变 隔离性:多个进程互不干扰 持久性: -旦提交不可逆,持久化到数据库了 隔离性的问题: 脏读: -个事务读取了另个没有提交的事务 不可重复读:在同事务内,重复读取表中的数据,表数据发生了改变 ...

    数据库中的事务:
    要么都成功,要么都失败
    ACID原则
    原子性:要么全部完成,要么都不完成
    -致性:总数不变
    隔离性:多个进程互不干扰
    持久性: -旦提交不可逆,持久化到数据库了


    隔离性的问题:
    脏读: -个事务读取了另一个没有提交的事务
    不可重复读:在同一个事务内,重复读取表中的数据,表数据发生了改变
    虚读(幻读) :在一个事务内,读取到了别人插入的数据,导致前后读出来结果不一致

    代码实现

    1.开启事务 connection. setAutocommit(false);//关闭数据库的自动提交,自动开启事务。
    2. 一组业务执行完毕,提交事务
    3.可以在catch 语句中显示的定义回滚语句,但默认失败就会回滚

    展开全文
  • 四大特性:原子、一致、隔离、...可重复读是指,事务执行过程中看到的数据,总是跟这个事务在启动时看到的数据是 的。当然在可重复读隔离级别下,未提交变更对其他事务也是不可见的。 串行化(seria

    **四大特性:**原子性、一致性、隔离性、持久性;
    隔离性的隔离级别:

    • 读未提交(read uncommitted):
      读未提交是指,一个事务还没提交时,它做的变更就能被别的事务看到。
    • 读提交(read committed):
      读提交是指,一个事务提交之后,它做的变更才会被其他事务看到。
    • 可重复读(repeatable read):
      可重复读是指,一个事务执行过程中看到的数据,总是跟这个事务在启动时看到的数据是一 致的。当然在可重复读隔离级别下,未提交变更对其他事务也是不可见的。
    • 串行化(serializable ):
      串行化,顾名思义是对于同一行记录,“写”会加“写锁”,“读”会加“读锁”。当出现读写锁冲突 的时候,后访问的事务必须等前一个事务执行完成,才能继续执行。
      以下举个例子方便理解这几种隔离级别:
      假设数据表T中 只有一列,其中一行的值为1,下面是按照时间顺序执行两个事务的行为。
    mysql> create table T(c int) engine=InnoDB;
     insert into T(c) values(1);
    

    在这里插入图片描述
    看看在不同的隔离级别下,事务A会有哪些不同的返回结果,也就是图里面V1、V2、V3 的返回值分别是什么。

    • 若隔离级别是“读未提交”, 则V1的值就是2。这时候事务B虽然还没有提交,但是结果已经被 A看到了。因此,V2、V3也都是2。

    • 若隔离级别是“读提交”,则V1是1,V2的值是2。事务B的更新在提交后才能被A看到。所以, V3的值也是2。

    • 若隔离级别是“可重复读”,则V1、V2是1,V3是2。之所以V2还是1,遵循的就是这个要求: 事务在执行期间看到的数据前后必须是一致的。

    • 若隔离级别是“串行化”,则在事务B执行“将1改成2”的时候,会被锁住。直到事务A提交后, 事务B才可以继续执行。所以从A的角度看, V1、V2值是1,V3的值是2。

      由于Oracle数据库的默认隔离级别其 实就是“读提交”,因此对于一些从Oracle迁移到MySQL的应用,为保证数据库隔离级别的一致, 你一定要记得将MySQL的隔离级别设置为“读提交”。
      查看mysql数据库当前的隔离级别:

    mysql> show variables like 'transaction_isolation';
    

    在这里插入图片描述

    展开全文
  • Spring事务

    2021-01-27 23:13:38
    一致: 事务执行前后数据完整保持- 隔离:事务的执行不应该受到其他事务的干扰 持久: - -旦事务结束,数据就持久化到数据库 3)如果不考虑隔离引发安全问题 读问题. 脏读:事务读到另事务未...

    1.事务的回顾

    1)什么事务

    事务:逻辑上的一-组操作,组成这组操作的各个单元,要么全都成功,要么全都失败。

    2)事务的特性

    原子性:事务不可分割
    一致性: 事务执行前后数据完整性保持-致
    隔离性:一个事务的执行不应该受到其他事务的干扰
    持久性: - -旦事务结束,数据就持久化到数据库

    3)如果不考虑隔离性引发安全性问题

    读问题.

    • 脏读:一个事务读到另一个事务未提交的数据
    • 不可重复读:一个事务读到另一个事务已经提交的update的数据,导致一个事务中多次查询结果不一致
    • 虚读、幻读:一个事务读到另一个事务已经提交的insert的数据,导致一个事务中多次查询结果不一致
      写问题
      丢失更新(锁机制:悲观锁、乐观锁)

    4)解决读问题

    设置事务的隔离级别
    Read uncommitted ::未提交读,任何读问题解决不了。
    Read committed :已提交读,解决脏读,但是不可重复读和虚读有可能发生。
    Repeatable read:重复读,解决脏读和不可重复读,但是虚读有可能发生。(MySQL默认)

    Serializable :解决所有读问题。

    2.Spring的事务管理的API

    PlatformTransactionManager:平台事务管理器
    平台事务管理器:接口,是Spring用 于管理事务的真正的对象。

    DataSourceTransacti onManager :底层使用JDBC管理事务
    HibernateTransact ionManager :底层使用Hibernate管理事务

    TransactionDefinition :事务定义信息
    事务定义:用于定义事务的相关的信息,隔离级别、超时信息、传播行为、是否只读
    I
    TransactionStatus:事务的状态
    I事务状态: 用于记录在事务管理过程中, 事务的状态的对象。

    3.事务管理的API的关系

    Spring进行事务管理的时候,首先平台事务管理器根据事务定义信息进行事务的管理,在事务管理过程中,产生各种状态,将这些状态的信息记录到事务状态的对象中。

    4.Spring的事务的传播行为

    Spring的传播行为
    Spring中提供了七种事务的传播行为:

    保证多个操作在同一个事务中
    PROPAGATION REOUIRED :默认值,如果A中有事务,使用A中的事务,如果A没有,创建一个新的事务,将操作包含进来
    PROPAGATION SUPPORTS :支持事务,如果A中有事务,使用A中的事务。如果A没有事务,不使用事务。
    PROPAGATION MANDATORY :如果A中有事务,使用A中的事务。如果A没有事务,抛出异常。

    保证多个操作不在同一个事务中,
    PROPAGATION REOUIRES NEW :如果A中有事务,将A的事务挂起(暂停),创建新事务,只包含自身操作。如果A中没有事务,创建-一个新事务,包含自身操作。
    PROPAGATION NOT SUPPORTED :如果A中有事务,将A的事务挂起。不使用事务管理。
    PROPAGATION NEVER :如果A中有事务,报异常。

    嵌套式事务
    PROPAGATION NESTED :嵌套事务,如果A中有事务,按照A的事务执行,执行完成
    后,设置一个保存点,执行B中的操作,如果没有异常,执行通过,如果有异常,可以
    选择回滚到最初始位置,也可以回滚到保存点。

    5.Spring的事务管理(银行转账演示)

    场景:
    A给B转账,需要A的账户,B的账户已经转账金额,当A账户扣钱成功且B账户加钱成功,说明转账成功,其余情况转账失败。只有成功的情况下才会将数据写入数据库。

    public class UserServiceImpl implements UserService{
        UserDao userDao = new UserDao();
        @Override
        public String aToB(String aname,String bname,int money) {
            //参数校验
            if(StringUtils.isEmpty(aname)||StringUtils.isEmpty((bname))){
                return "转账用户不能为空";
            }
            if(money<=0){
                return "转账金额不能小于0";
            }
            //转账
            //1.a扣钱
            int a = userDao.updateByUnameAndMoneySub(aname,money);
            //2.b加钱
            int b = userDao.updateByUnameAndMoneyAdd(bname,money);
    
            return a>0&&b>0?"转账成功":"转账失败";
        }
    }
    
    public class UserDao {
    
        public int updateByUnameAndMoneySub(String uname,int money){
            //创建spring核心容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdt = (JdbcTemplate) ac.getBean("jdbcTemplate");
            //扣钱
            String sql = "UPDATE users SET money=money-? WHERE name=? ";
            int a = jdt.update(sql, money,uname);
    
            return a;
        }
    
        public int updateByUnameAndMoneyAdd(String uname,int money){
            //创建spring核心容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdt = (JdbcTemplate) ac.getBean("jdbcTemplate");
            //加钱
            String sql = "UPDATE users SET money=money+? WHERE name=? ";
            int a = jdt.update(sql, money,uname);
    
            return a;
        }
    
    }
    

    6. Spring的事务管理:

    一类:编程式事务(需要手动编写代码) -了解
    引入新的约束:

    在这里插入图片描述
    在这里插入图片描述

    package com.xhl.dao;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class UserDao {
        JdbcTemplate jdt;
    
        public JdbcTemplate getJdt() {
            return jdt;
        }
    
        public void setJdt(JdbcTemplate jdt) {
            this.jdt = jdt;
        }
    
        public int updateByUnameAndMoneySub(String uname, int money){
    
            //扣钱
            String sql = "UPDATE users SET money=money-? WHERE name=? ";
            int a = jdt.update(sql, money,uname);
    
            return a;
        }
    
        public int updateByUnameAndMoneyAdd(String uname,int money){
    
            //加钱
            String sql = "UPDATE users SET money=money+? WHERE name=? ";
            int a = jdt.update(sql, money,uname);
    
            return a;
        }
    
    }
    
    
    <?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:context="http://www.springframework.org/schema/context"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
           http://www.springframework.org/schema/context
    	   http://www.springframework.org/schema/context/spring-context-4.2.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">
    
        <context:property-placeholder location="classpath:db.properties"/>
    
    
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="${jdbc.driverClassName}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
    
    
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
    <!--    管理业务层-->
        <bean id="userService" class="com.xhl.service.UserServiceImpl">
            <property name="userDao" ref="userDao"/>
            <property name="template" ref="transactionTemplate"/>
    
        </bean>
        
    <!--    管理数据层-->
        <bean id="userDao" class="com.xhl.dao.UserDao">
            <property name="jdt" ref="jdbcTemplate"/>
        </bean>
    
    <!--    平台事务管理器-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
    <!--    配置事务管理的模板-->
        <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
            <property name="transactionManager" ref="transactionManager"/>
        </bean>
    
    
    
    </beans>
    
    package com.xhl.service;
    
    import com.xhl.dao.UserDao;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.transaction.support.TransactionCallbackWithoutResult;
    import org.springframework.transaction.support.TransactionTemplate;
    import org.springframework.util.StringUtils;
    
    public class UserServiceImpl implements UserService{
        private UserDao userDao;
    
        public UserDao getUserDao() {
            return userDao;
        }
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    //  注入平台事务管理模板
        private TransactionTemplate template;
    
        public TransactionTemplate getTemplate() {
            return template;
        }
    
        public void setTemplate(TransactionTemplate template) {
            this.template = template;
        }
    
        static String msg = "";
        @Override
        public String aToB(String aname,String bname,int money) {
    
            template.execute(new TransactionCallbackWithoutResult() {
                @Override
                protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                    //参数校验
                    if(StringUtils.isEmpty(aname)||StringUtils.isEmpty((bname))){
                        msg= "转账用户不能为空";
                    }
                    if(money<=0){
                        msg="转账金额不能小于0";
                    }
                    //转账
                    //1.a扣钱
                    int a = userDao.updateByUnameAndMoneySub(aname,money);
    
    //                人为异常(执行到这一步出现异常后会回滚之前的操作
                    int x = 1/0;
    
                    //2.b加钱
                    int b = userDao.updateByUnameAndMoneyAdd(bname,money);
    
                    msg= a>0&&b>0?"转账成功":"转账失败";
                }
            });
            return msg;
        }
    }
    
    
    @Test
        public void test1(){
            //创建spring核心容器
            ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
            String aname = "a用户",bname = "b用户";
            int money = 10;
            UserService userService = ac.getBean("userService",UserServiceImpl.class);
            String s = userService.aToB(aname,bname,money);
            System.out.println(s);
        }
    

    7. Spring的事务管理:

    二类:声明式事务管理(通过配置实现) _ AOP
    XML方式的声明式事务管理

    第一步:引入aop的开发包(用maven的工程,直接导入坐标)
    第二步:恢复转账环境
    第三步:配置事务管理器‘

    <!--    使用AOP的事务-->
        <tx:advice id="interceptor" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="aToBByAOP" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
    
    <!--    配置AOP,这里相当于把事务增强的通知放入到切入点中,即给需要增强的类下的方法通知-->
        <aop:config>
            <aop:pointcut id="p1" expression="execution(* com.xhl.service.UserService.aToBByAOP(..))"/>
            <aop:advisor advice-ref="interceptor" pointcut-ref="p1"/>
        </aop:config>
    
    //      声明式事务处理
        @Override
        public String aToBByAOP(String aname, String bname, int money) {
            //参数校验
            if(StringUtils.isEmpty(aname)||StringUtils.isEmpty((bname))){
                return "转账用户不能为空";
            }
            if(money<=0){
                return "转账金额不能小于0";
            }
            //转账
            //1.a扣钱
            int a = userDao.updateByUnameAndMoneySub(aname,money);
    
    //                人为异常
            int x = 1/0;
    
            //2.b加钱
            int b = userDao.updateByUnameAndMoneyAdd(bname,money);
    
            return a>0&&b>0?"转账成功":"转账失败";
        }
    

    注解方式的声明式事务管理
    第一步:引入aop的开发包
    第二步:恢复转账环境
    第三步:配置事务管理器

    在这里插入图片描述

    展开全文
  • 本地事务与分布式事务 本地事务 事务的基本性质 事务的概念:事务是逻辑上组操作,组成这组操作各个逻辑单元,... 致性:数据在事务的前后,业务整体一致。 转账。A:1000; B:1000; 转200 事务成功; A: 800 B
  • ADO事务

    2017-07-10 14:40:00
    事务处理介绍 事务是这样种机制,它确保多个SQL语句被当作单个工作单 元... 二 事务与一致 事务是完整的单位,事务的执行是把数据库从 的状态转换成另个一致的状态。因此,如果事务孤立执行...
  • 2.事务特性原子:在事务的操纵中,要么都执行、要么都不执行一致事务中,保证数据从个一致状态变为另一一状态隔离:每个事务互不干扰,一起执行也可持久事务提交后,数据的影响是永久...
  • 目录 Spring事务以及事务传播行为详解 事务的概念 二:事务的四大特性 ...2:⼀致性(Consistency) 3:隔离性(Isolation) 4:持久性(Durability) 三:事务的隔离级别 1:脏读 2:不可重复读...
  • 分布式事务

    2020-09-11 21:05:13
    文章内容输出来源:拉勾教育Java高薪训练营 1.介绍 分布式事务是指单个事件导致两个或多个不能以原子方式提交的单独数据源的突变的任何情况。...⼀致性(Consistency): 事务必须使数据库从⼀个⼀致
  • MySQL 事务

    2020-11-02 15:44:17
    致性(Consistency)3.隔离性(Isolation)4.持久性(Duration)三、事务的并发问题四、事务隔离级别1.读未提交(READ_UNCOMMITTED)2.读已提交(READ_COMMITTED)3.可重复读(REPEATABLE_READ)4.顺序读...
  • SQL之事务

    2019-05-10 21:40:00
    事务的ACID(acid)属性 ...事务必须使数据库从一一个--致性状态变换到另外一一个--致性状态 ➢3.隔离性(Isolation) 事务的隔离性是指- 个事务的执行不能被其他事务干扰,即一一个事务内部的操作及使用的数据对...
  • ADO.net 事务

    2019-10-02 23:09:54
    事务处理介绍 事务是这样种机制,它确保多个SQL语句被当作单个工作单 元来处理。... 二 事务与一致 事务是完整的单位,事务的执行是把数据库从 的状态转换成另个一致的状态。因此,如果事...
  • 事务处理

    2010-11-07 18:42:37
    事务处理介绍 事务是这样种机制,它确保多个SQL语句被当作单个工作单 元来处理。... 二 事务与一致 事务是完整的单位,事务的执行是把数据库从 的状态转换成另个一致的状态...
  • MySQL事务功能

    2018-08-10 11:13:15
    MySQL事务功能 1.事务简述 事务个连续的组数据库操作,就好像它是个单一的...一致事务中,保证数据从个一致状态变为另一一状态 隔离:每个事务互不干扰,一起执行也可 持久事务提交后...
  • 个逻辑工作单元必须有四个属性,称为 ACID(原子性、致性、隔离性和持久性)属性,只有这样才能成为事务。 数据库事物的四大特性(ACID): 1)原子性:(Atomicity) 务必须是原子工...
  • mysql事务解析

    2020-10-20 15:34:35
    事务的概念 ■是种机制、个操作序列,包含了-...■通过事务的整体性以保证数据的-致性 事务的四大特性 1、原子性(Atomicity) ●事务个完整的操作,事务的各元素是不可分的 ●事务中的所有元素必须作为-个整体提
  • 数据库事务隔离

    2019-04-18 15:56:24
    读未提交是指,事务还没提交时,它做的变更就能被别的事务看到。 读提交是指,事务提交之后,它做的变更才会被其他事务看到。 可重复读是指,事务执行过程中看到的数据,总是跟这个事务在启动时看到的...
  • 展开全部ACID指数据库事务正确执行的四个基本要素的缩写,包含原子性(atomicity)、32313133353236313431303231363533e58685e5aeb931333436316330致性(consistency)、隔离性(isolation)和持久性(durability)。个...
  • 什么是事务?

    2020-05-27 17:15:58
    要将组语句作为事务考虑,就需要通过ACID测试,即原子性,致性,隔离性和持久性。 2.分类 a.显示事务 :也称之为用户定义或用户指定的事务,即可以显式地定义启动和结束的事务。分布式事务属于显示事务 b.自动提交...
  • Mysql 特性 索引 事务

    2020-07-06 18:02:19
    2.一致(Consistency) :执行事务前后,数据保持 ,多个事务对同个数据读取的结果是相同的; 3.隔离(Isolation) :并发访问数据库时,个用户的事务不被其他事务所干扰,各并发事务之间数据库是独立的; 4....
  • 事务必须使数据库从个- -致性状态变换到另外-个一致性状态。 ➢3.隔离性(Isolation) 事务的隔离性是指- 事务的执行不能被其他事务干扰,即事务内部的操作及使用的数据对并发的其...
  • 一致性(Consistency):致性是指事务必须使数据库从个一致性状态变换到另个一致性状态,也就是说事务执行之前和执行之后都必须处于一致性状态。 c.隔离性(Isolation):隔离性是当多个用户并发访问数据库时...
  • 事务的四个特性

    2017-10-24 15:33:58
    一致性是指事务必须使数据库从致性状态变换到另个一致性状态,也就是说事务执行之前和执行之后都必须处于一致性状态。一致性的必须通过原子性来实现,同时还需要逻辑的正确,保证数据的守恒。 三、隔离性...
  • 数据库的事务处理

    千次阅读 2017-01-10 17:26:22
    事务是这样种机制,它确保多个SQL语句被当作单个工作单 元来处理。... 事务是完整的单位,事务的执行是把数据库从 的状态转换成另个一致的状态。因此,如果事务孤立执行时 是正确
  • ADO.NET事务处理

    2012-03-02 00:14:01
    事务处理介绍 事务是这样种机制,它确保多个SQL语句被当作单个工作单 元来处理。事务具有以下的作用: * 一致:同时进行的查询...事务是完整的单位,事务的执行是把数据库从 的状态转换成
  • mysql--事务概述

    2020-05-04 12:14:37
    一致(Consistent) :在事务开始和完成时,数据都必须保持 状态。这意味着所有相关的数据规则都必须应用于事务的修改以保持数据的完整;事务结束时,所有的内部数据结构(如B树索引或双向链表)也都...

空空如也

空空如也

1 2 3 4 5
收藏数 87
精华内容 34
关键字:

一事务致性