精华内容
下载资源
问答
  • Hibernate中的事务理解

    千次阅读 2015-12-17 09:45:30
    1.数据库事务的概念 数据库事务是指由一个或多个SQL语句组成的工作单元,这个工作单元中的SQL语句相互依赖,如果有一个SQL语句执行失败,就必须撤销整个工作单元。  在并发环境中,多个事务同时访问相同的...

    1.数据库事务的概念

    数据库事务是指由一个或多个SQL语句组成的工作单元,这个工作单元中的SQL语句相互依赖,如果有一个SQL语句执行失败,就必须撤销整个工作单元。

       在并发环境中,多个事务同时访问相同的数据资源时,可能会造成各种并发问题,可通过设定数据库的事务隔离级别来避免,还可采用悲观锁和乐观锁来解决丢失更新这一并发问题。

       数据库事务必须具备ACID特征:

      A: Atomic原子性,整个事务不可分割,要么都成功,要么都撤销。  

      C: Consistency一致性,事务不能破坏关系数据的完整性和业务逻辑的一致性,例如转账,应保证事务结束后两个账户的存款总额不变。

      I:  Isolation隔离性,多个事务同时操纵相同数据时,每个事务都有各自的完整数据空间  D: Durability持久性,只要事务成功结束,对数据库的更新就必须永久保存下来,即使系

    统发生崩溃,重启数据库后,数据库还能恢复到事务成功结束时的状态。

    2.事务边界声明

    只要声明了一个事务,数据库系统就会自动保证事务的ACID特性。

         

          声明事务包含:

          事务的开始边界

          事务的正常结束边界(commit):提交事务,永久保存

          事务的异常结束边界(rollback):撤销事务,数据库回退到执行事务前的状态

         

         数据库支持两种事务模式:

          自动提交模式:每个SQL语句都是一个独立的事务,数据库执行完一条SQL语句后,会自动提交事务。

          手工提交模式:必须由数据库的客户程序显式指定事务的开始和结束边界

         

          JDBC Connection类的事务控制方法:

          setAutoCommit(boolean autoCommit) 设置是否自动提交事务,默认自动

          commit() 提交事务

          rollback() 撤销事务
    Hibernate控制事务的方法:

         1. 调用sessionFactory不带参数的openSession方法,从连接池获得连接,Session自动把连接设为手工提交事务模式。

          Session   session = sessionFactory.openSession();

          若调用带connection参数的openSession,则需要自己设置手工提交:

          connection.setAutoCommit(false);

          Session   session = sessionFactory.openSession(connection);
          2. 声明事务的开始边界

          Transaction tx = session.beginTransaction();

          3. 提交事务

           tx.commit();

          4. 撤销事务:

           tx.rollback(); 

          一个session可以对应多个事务,但是应优先考虑让一个session只对应一个事务,当一个事务结束或撤销后,就关闭session.

         不管事务成功与否,最后都应调用session的close关闭session

          任何时候一个session只允许有一个未提交的事务,不能同时开始两个事务

    3.多事务并发问题

    同时运行多个事务访问相同数据时,可能会导致5类并发问题:

          1. 第一类丢失更新:撤销一个事务时,把其他事务已提交的更新覆盖

          2. 脏读:一个事务读到另一事务未提交的更新数据

          3. 虚读:一个事务读到另一事务已提交的新插入的数据

          4. 不可重复读:一个事务读到另一事务已提交的更新数据

          5. 第二类丢失更新:一个事务覆盖另一事务已提交的更新数据,不可重复读的特例

         

           1. 第一类丢失更新:

           t1 开始事务

           t2 开始事务

           t3 查询存款余额为1000元

           t4 查询存款余额为1000元

           t5汇入100元,把存款余额改为1100元

           t6提交事务

           t7取出100元,把存款余额改为900元

           t8撤销事务,账户的存款余额恢复为1000元

           2. 脏读:

           t1开始事务

           t2开始事务
           t3查询存款余额为1000元

           t4

           t5取出100元,把存款余额改为900元

           t6查询账户余额为900元(脏读)

           t7撤销事务,账户的存款余额恢复为1000元

           t8汇入100元,存款余额改为1000元

           t9提交事务

           3. 虚读:

           t1开始事务

           t2开始事务

          t3统计网站注册人数为1000人

           t4注册一个新用户

           t5提交事务

           t6统计网站注册人数为1000人(虚读)

           t7到底哪个统计数据有效?

           4. 不可重复读:

           t1开始事务

           t2开始事务
           t3查询账户余额为1000元                                                              

           t4查询账户余额为1000元

           t5取出100元,余额改为900元

           t6提交事务

           t7查询账户余额为900元

           t8到底余额是1100元还是900+100元?

           5. 第二类丢失更新:

           t1开始事务

           t2开始事务

           t3查询账户余额为1000元                                                              

           t4查询账户余额为1000元

           t5取出100元,余额改为900元

           t6提交事务

           t7汇入100元,把存款余额改为1100元

           t8提交事务


    4.数据库锁

    数据库必须具有隔离并发运行的各个事务的能力,数据库采用锁来实现事务的隔

    离性。

    根据数据库能够锁定的资源,可分为以下锁:

    数据库级锁

    表级锁

    区域级锁

    页面级锁

    键值锁: 锁定数据库表中带有索引的一行数据

    行级锁:锁定数据库表中的单行记录

    锁的封锁粒度越大,隔离性越高,并发性越低

    锁升级指调整锁的粒度,将多个低粒度锁替换成更高粒度的锁,以降低系统负荷。

    按照封锁程度,锁可分为:

    共享锁:用于读数据,非独占,允许其他事务同时读取锁定的资源,但不允许其 

    他事务更新。

     加锁:执行select语句时,数据库会为事务分配共享锁,锁定被查询的数据。

     解锁:数据被读取后,立即解除

    兼容性:还可再放置共享锁和更新锁 

    独占锁:

    也叫排他锁,用于修改数据,锁定的资源不能被其他事务读取和修改。

    加锁的条件:一个事务执行insert  update  delete语句时,自动使用独占锁,若已有其他锁存在,无法再独占锁

    解锁的条件:一直事务结束才能被解除

    兼容性:不能和其他锁兼容,不能再放置其他任何锁。

    并发性能:较差,只允许有一个事务访问锁定的数据,其他事务要访问,必读等待,直到前一个事务结束,解除了独占锁。

    更新锁:

    在更新操作的初始化阶段用来锁定可能要修改的资源,避免使用共享锁造成的死

    锁现象。

    如果使用共享锁,更新数据的操作分为两步:

    1.获得一个共享锁,读取一条记录

    2.将共享锁升级为独占锁,再执行更新操作

    如果同时多个事务同时更新该数据,每个事务都先获得一把共享锁,在更新数据

    的时候,这些事务都要先将共享锁升级为独占锁。由于独占锁不能与其他锁并存,

    因此每个事务都进入等待,等待其他事务释放共享锁,造成了死锁。

    如果使用更新锁,更新数据的操作分为以下两步:

    1.获得一个更新锁,读取一条记录

    2.将更新锁升级为独占锁,再执行更新操作

    更新锁的特征:

    加锁的条件:一个事务执行update语句时,数据库先为事务分配一把更新锁

    解锁的条件:读取数据完毕,执行更新操作时,会把更新锁升级为独占锁。

    兼容性:更新锁与共享锁是兼容的,可以同时放置,但是最多只能放一把更新锁,以确保多个事务更新数据时,只有一个事务能获得更新锁,再把更新锁升级为独占锁,其他事务必须等到前一个事务结束后,才能获得更新锁,这就避免了死锁。

    并发性能: 允许多个事务同时读锁定的资源,但不允许其他事务修改它。

    死锁及其预防:

    死锁是指多个事务分别锁定了一个资源,又试图请求锁定对方已经锁定的资源,这就产生了

    一个锁定请求环,导致多个事务都处于等待对方释放锁定资源的状态。

    预防:

    合理安排表访问顺序

    使用短事务

    允许脏读

    错开执行时间

    使用尽可能低的事务隔离级别

    5.事务隔离级别

    锁机制能解决各种并发问题,但是会影响并发性能,为了能让用户根据实际应用的需要,在

    事务的隔离性和并发性之间做出合理权衡,数据库系统提供了四种事务隔离级别供用户选择:

    8 Serializable:串行化  完全看不到其他事务的更新,串行等待

    4 Repeatable Read:可重复读  事务可看到其他事务已提交的新插入记录,但是不能看到其他事务对已有记录的更新

    2 Read Commited:读已提交数据  事务可看到其他事务已提交的新插入记录,还能看到其他事务已经提交的对已有记录的更新

    1 Read  Uncommited: 读未提交数据  事务可看到其他事务没有提交的新插入记录,还能看到其他事务没有提交的对已有记录的更新

    优先考虑隔离级别为Read Commited,能避免脏读,有较好的并发性能,可能会导致不可重复读、虚读和第二类丢失更新,但是可以采用悲观锁或乐观锁来控制。

     

    Hibernate中设置事务隔离级别:

     hibernate.connection.isolation = 2          (Read Commited)

    6.悲观锁和乐观锁

    悲观锁:先锁定资源,能防止丢失更新和不可重复读问题,但是影响并发性能

    乐观锁:完全依靠数据库的隔离级别来自动管理锁的工作,采用版本控制可避免并发问题。

    悲观锁的实现:

    显式指定独占锁来锁定资源

        select语句默认采用共享锁

        可采用 select  .. for update  来显式指定采用独占锁来锁定查询的记录

        Hibernate采用LockMode来实现锁定模式

    2. 增加一个LOCK 字段

        Hibernate 采用<version>和<timestamp>来实现版本控制

    乐观锁的实现:

    <class name=“”  table=“”  optimistic-lock=“all” dynamic-update=“true”>

    展开全文
  • 数据库中事务理解

    千次阅读 2017-06-01 16:21:38
    也可以理解为集合中的一系列操作协作完成事务。 二、特性 事务的特性也成为ACID特性。即原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)。 1.原子性:原子性是指事务中...

    一、定义
    事务一系列操作的集合。也可以理解为集合中的一系列操作协作完成事务。
    二、特性
    事务的特性也成为ACID特性。即原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)。
    1.原子性:原子性是指事务中包含的所有操作要么都做,要么都不做,保证数据库是一致的。
    2.一致性:一致性是指数据库在事务操作前和事务处理后,其中的数据必须都满足业务规则约束。
    3.隔离性:隔离性是数据库允许多个并发事务同时对齐数据进行读写和修改的能力,隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。
    4.持久性:持久性表示为:事务处理结束后,对数据的修改就是永久的,即便系统故障也不会丢失。

    三、Mysql事务使用
    1.在默认情况下,MySQL每执行一条SQL语句,都是一个单独的事务。如果需要在一个事务中包含多条SQL语句,那么需要开启事务和结束事务。
    开启事务:start transaction;
    结束事务:commit或rollback。
    2.在执行SQL语句之前,先执行start transaction,这就开启了一个事务(事务的起点),然后可以去执行多条SQL语句,最后要结束事务,commit表示提交,即事务中的多条SQL语句所做出的影响会持久化到数据库中。或者rollback,表示回滚,即回滚到事务的起点,之前做的所有操作都被撤消了!
    注:个人刷题整理笔记,参考自牛客网选择题。

    展开全文
  • 事务理解

    千次阅读 2016-12-01 18:44:30
    一、事务事务(Transaction),是指访问并可能更新数据库中各种数据项的一个程序执行单元(Unit),通俗点也就是指针对数据库中形形色色的数据,我们进行一些存取操作。 事务通常是由用户编写的程序执行所引起的...

    一、事务:
    事务(Transaction),是指访问并可能更新数据库中各种数据项的一个程序执行单元(Unit),通俗点也就是指针对数据库中形形色色的数据,我们进行一些存取操作。
    事务通常是由用户编写的程序执行所引起的,并用形如begin transaction和end transaction语句(或函数调用)来界定。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。例如:在关系数据库中,一个事务可以是一条SQL语句,一组SQL语句或整个程序。
    事务是恢复和并发控制的基本单位。具有四个属性:原子性、一致性、阻离性、持久性,合起来通常被称为ACID特性。
    1、原子性(atomicity)。一个事务是一个不可分割的工作单位,事务中包括的诸操作要么都做,要么都不做。
    2、一致性(consistency)。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
    3、隔离性(isolation)。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。
    4、持久性(durability)。持久性也称永久性(permanence),指一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

    二、java的事务处理:
    Java的事务处理,如果对数据库进行多次操作,每一次的执行或步骤都是一个事务.如果数据库操作在某一步没有执行或出现异常而导致事务失败,这样有的事务被执行有的就没有被执行,从而就有了事务的回滚,取消先前的操作…..
    Java中使用事务处理,首先要求数据库支持事务。如使用MySQL的事务功能,就要求MySQL的表类型为Innodb才支持事务。否则,在Java程序中做了commit或rollback,但在数据库中根本不能生效。
    JavaBean中使用JDBC方式进行事务处理:

    public int delete(int sID) {
    
            dbc = new DataBaseConnection();
    
            Connection con = dbc.getConnection();
    
            try {
    
                con.setAutoCommit(false);// 更改JDBC事务的默认提交方式
    
                dbc.executeUpdate("delete from xiao where ID=" + sID);
    
                dbc.executeUpdate("delete from xiao_content where ID=" + sID);
    
                dbc.executeUpdate("delete from xiao_affix where bylawid=" + sID);
    
                con.commit();// 提交JDBC事务
    
                con.setAutoCommit(true);// 恢复JDBC事务的默认提交方式
    
                dbc.close();
    
                return 1;
    
            }
    
            catch (Exception exc) {
    
                con.rollBack();// 回滚JDBC事务
    
                exc.printStackTrace();
    
                dbc.close();
    
                return -1;
    
            }
    
        }

    在数据库操作中,一项事务是指由一条或多条对数据库更新的sql语句所组成的一个不可分割的工作单元。只有当事务中的所有操作都正常完成了,整个事务才能被提交到数据库,如果有一项操作没有完成,就必须撤消整个事务。

    例如在银行的转帐事务中,假定张三从自己的帐号上把1000元转到李四的帐号上,相关的sql语句如下:

    update account set monery=monery-1000 where name='zhangsan'
    
    update account set monery=monery+1000 where name='lisi'

    这个两条语句必须作为一个完成的事务来处理。只有当两条都成功执行了,才能提交这个事务。如果有一句失败,整个事务必须撤消。

    三、控制事务的方法:
    在connection类中提供了3个控制事务的方法:

    (1) setAutoCommit(Boolean autoCommit):设置是否自动提交事务;

    (2) commit();提交事务;

    (3) rollback();撤消事务;

    在jdbc api中,默认的情况为自动提交事务,也就是说,每一条对数据库的更新的sql语句代表一项事务,操作成功后,系统自动调用commit()来提交,否则将调用rollback()来撤消事务。

    在jdbc api中,可以通过调用setAutoCommit(false) 来禁止自动提交事务。然后就可以把多条更新数据库的sql语句做为一个事务,在所有操作完成之后,调用commit()来进行整体提交。倘若其中一项 sql操作失败,就不会执行commit()方法,而是产生相应的sqlexception,此时就可以捕获异常代码块中调用rollback()方法撤消事务。

    事务处理是企业应用需要解决的最主要的问题之一。J2EE通过JTA提供了完整的事务管理能力,包括多个事务性资源的管理能力。但是大部分应用都是运行在单一的事务性资源之上(一个数据库),他们并不需要全局性的事务服务。本地事务服务已然足够(比如JDBC事务管理)。

    四、数据库系统支持两种事务模式:
    •自动提交模式:每个SQL语句都是一个独立的事务,当数据库系统执行完一个SQL语句后,会自动提交事务。
     •手动提交模式:必须由数据库客户程序显示指定事务开始边界和结束边界。
      注:MySQL中数据库表分为3种类型:INNODB、BDB和MyISAM,其中MyISAM不支持数据库事务。MySQL中create table 语句默认为MyISAM类型。

    五、事务并发引起的问题:
    对于同时运行的多个事务,当这些事务访问数据库中相同的数据时,如果没有采取必要的隔离机制,就会导致各种并发问题,这些并发问题可归纳为以下几类:
    1、脏读(dirty read):一个事务读取了另一个事务尚未提交的数据。
    2、幻读(phantom read):一个事务的操作导致另一个事务前后两次读取到不同的数据。
    3、不可重复读(no-repeatable read):一个事务的操作导致另一个事务前后两次读取到不同的数据。
    4、第一类丢失更新:撤销一个事务时,把其他事务已提交的更新数据覆盖。
    5、第二类丢失更新:这是不可重复读中的特例,一个事务覆盖另一个事务已提交的更新数据。  

    六、处理并发,隔离级别:
      当数据库系统采用read Commited隔离级别时,会导致不可重复读喝第二类丢失更新的并发问题,可以在应用程序中采用悲观锁或乐观锁来避免这类问题。从应用程序的角度,锁可以分为以下几类:
    •Serializable(串行化):一个事务在执行过程中完全看不到其他事务对数据库所做的更新。
    •Repeatable Read(可重复读):一个事务在执行过程中可以看到其他事务已经提交的新插入的记录,但是不能看到其他事务对已有记录的更新。
    •Read Commited(读已提交数据):一个事务在执行过程中可以看到其他事务已经提交的新插入的记录,而且能看到其他事务已经提交的对已有记录的更新
    •Read Uncomitted(读未提交数据):一个事务在执行过程中可以拷打其他事务没有提交的新插入的记录,而且能看到其他事务没有提交的对已有记录的更新。

    隔离级别越高,越能保证数据的完整性和一致性,但是对并发性能的影响也越大。对于多数应用程序,可以有优先考虑把数据库系统的隔离级别设为Read Commited,它能够避免脏读,而且具有较好的并发性能。尽管它会导致不可重复读、虚读和第二类丢失更新这些并发问题,在可能出现这类问题的个别场合,可以由应用程序采用悲观锁或乐观锁来控制。

      当数据库系统采用read Commited隔离级别时,会导致不可重复读喝第二类丢失更新的并发问题,可以在应用程序中采用悲观锁或乐观锁来避免这类问题。从应用程序的角度,锁可以分为以下几类:

      A.悲观锁:指在应用程序中显示的为数据资源加锁。尽管能防止丢失更新和不可重复读这类并发问题,但是它会影响并发性能,因此应该谨慎地使用。

      B.乐观锁:乐观锁假定当前事务操作数据资源时,不回有其他事务同时访问该数据资源,因此完全依靠数据库的隔离级别来自动管理锁的工作。应用程序采用版本控制手段来避免可能出现的并发问题。

    悲观锁有两种实现方式:
      1、在应用程序中显示指定采用数据库系统的独占所来锁定数据资源。SQL语句:select … for update,在Hibernate中使用get,load时如session.get(Account.class,new Long(1),LockMode,UPGRADE)
      2、在数据库表中增加一个表明记录状态的LOCK字段,当它取值为“Y”时,表示该记录已经被某个事务锁定,如果为“N”,表明该记录处于空闲状态,事务可以访问它。增加锁标记字段就可以实现。
    利用Hibernate的版本控制来实现乐观锁:乐观锁是由程序提供的一种机制,这种机制既能保证多个事务并发访问数据,又能防止第二类丢失更新问题。
      在应用程序中可以利用Hibernate提供的版本控制功能来视线乐观锁,OR映射文件中的元素和都具有版本控制的功能,一般推荐采用

    展开全文
  • 深入理解分布式事务,高并发下分布式事务的解决方案

    1、什么是分布式事务

    分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。以上是百度百科的解释,简单的说,就是一次大的操作由不同的小操作组成,这些小的操作分布在不同的服务器上,且属于不同的应用,分布式事务需要保证这些小操作要么全部成功,要么全部失败。本质上来说,分布式事务就是为了保证不同数据库的数据一致性。

    2、分布式事务的产生的原因

    2.1、数据库分库分表

    当数据库单表一年产生的数据超过1000W,那么就要考虑分库分表,具体分库分表的原理在此不做解释,以后有空详细说,简单的说就是原来的一个数据库变成了多个数据库。这时候,如果一个操作既访问01库,又访问02库,而且要保证数据的一致性,那么就要用到分布式事务。


    2.2、应用SOA化

    所谓的SOA化,就是业务的服务化。比如原来单机支撑了整个电商网站,现在对整个网站进行拆解,分离出了订单中心、用户中心、库存中心。对于订单中心,有专门的数据库存储订单信息,用户中心也有专门的数据库存储用户信息,库存中心也会有专门的数据库存储库存信息。这时候如果要同时对订单和库存进行操作,那么就会涉及到订单数据库和库存数据库,为了保证数据一致性,就需要用到分布式事务。


    以上两种情况表象不同,但是本质相同,都是因为要操作的数据库变多了!

    3、事务的ACID特性

    3.1、原子性(A)

    所谓的原子性就是说,在整个事务中的所有操作,要么全部完成,要么全部不做,没有中间状态。对于事务在执行中发生错误,所有的操作都会被回滚,整个事务就像从没被执行过一样。

    3.2、一致性(C)

    事务的执行必须保证系统的一致性,就拿转账为例,A有500元,B有300元,如果在一个事务里A成功转给B50元,那么不管并发多少,不管发生什么,只要事务执行成功了,那么最后A账户一定是450元,B账户一定是350元。

    3.3、隔离性(I)

    所谓的隔离性就是说,事务与事务之间不会互相影响,一个事务的中间状态不会被其他事务感知。

    3.4、持久性(D)

    所谓的持久性,就是说一单事务完成了,那么事务对数据所做的变更就完全保存在了数据库中,即使发生停电,系统宕机也是如此。

    4、分布式事务的应用场景

    4.1、支付

    最经典的场景就是支付了,一笔支付,是对买家账户进行扣款,同时对卖家账户进行加钱,这些操作必须在一个事务里执行,要么全部成功,要么全部失败。而对于买家账户属于买家中心,对应的是买家数据库,而卖家账户属于卖家中心,对应的是卖家数据库,对不同数据库的操作必然需要引入分布式事务。

    4.2、在线下单

    买家在电商平台下单,往往会涉及到两个动作,一个是扣库存,第二个是更新订单状态,库存和订单一般属于不同的数据库,需要使用分布式事务保证数据一致性。

    5、常见的分布式事务解决方案

    5.1、基于XA协议的两阶段提交

    XA是一个分布式事务协议,由Tuxedo提出。XA中大致分为两部分:事务管理器和本地资源管理器。其中本地资源管理器往往由数据库实现,比如Oracle、DB2这些商业数据库都实现了XA接口,而事务管理器作为全局的调度者,负责各个本地资源的提交和回滚。XA实现分布式事务的原理如下:


    总的来说,XA协议比较简单,而且一旦商业数据库实现了XA协议,使用分布式事务的成本也比较低。但是,XA也有致命的缺点,那就是性能不理想,特别是在交易下单链路,往往并发量很高,XA无法满足高并发场景。XA目前在商业数据库支持的比较理想,在mysql数据库中支持的不太理想,mysql的XA实现,没有记录prepare阶段日志,主备切换回导致主库与备库数据不一致。许多nosql也没有支持XA,这让XA的应用场景变得非常狭隘。

    5.2、消息事务+最终一致性

    所谓的消息事务就是基于消息中间件的两阶段提交,本质上是对消息中间件的一种特殊利用,它是将本地事务和发消息放在了一个分布式事务里,保证要么本地操作成功成功并且对外发消息成功,要么两者都失败,开源的RocketMQ就支持这一特性,具体原理如下:


    1、A系统向消息中间件发送一条预备消息
    2、消息中间件保存预备消息并返回成功
    3、A执行本地事务
    4、A发送提交消息给消息中间件

    通过以上4步完成了一个消息事务。对于以上的4个步骤,每个步骤都可能产生错误,下面一一分析:

    • 步骤一出错,则整个事务失败,不会执行A的本地操作
    • 步骤二出错,则整个事务失败,不会执行A的本地操作
    • 步骤三出错,这时候需要回滚预备消息,怎么回滚?答案是A系统实现一个消息中间件的回调接口,消息中间件会去不断执行回调接口,检查A事务执行是否执行成功,如果失败则回滚预备消息
    • 步骤四出错,这时候A的本地事务是成功的,那么消息中间件要回滚A吗?答案是不需要,其实通过回调接口,消息中间件能够检查到A执行成功了,这时候其实不需要A发提交消息了,消息中间件可以自己对消息进行提交,从而完成整个消息事务

    基于消息中间件的两阶段提交往往用在高并发场景下,将一个分布式事务拆成一个消息事务(A系统的本地操作+发消息)+B系统的本地操作,其中B系统的操作由消息驱动,只要消息事务成功,那么A操作一定成功,消息也一定发出来了,这时候B会收到消息去执行本地操作,如果本地操作失败,消息会重投,直到B操作成功,这样就变相地实现了A与B的分布式事务。原理如下:


    虽然上面的方案能够完成A和B的操作,但是A和B并不是严格一致的,而是最终一致的,我们在这里牺牲了一致性,换来了性能的大幅度提升。当然,这种玩法也是有风险的,如果B一直执行不成功,那么一致性会被破坏,具体要不要玩,还是得看业务能够承担多少风险。

    5.3、TCC编程模式

    所谓的TCC编程模式,也是两阶段提交的一个变种。TCC提供了一个编程框架,将整个业务逻辑分为三块:Try、Confirm和Cancel三个操作。以在线下单为例,Try阶段会去扣库存,Confirm阶段则是去更新订单状态,如果更新订单失败,则进入Cancel阶段,会去恢复库存。总之,TCC就是通过代码人为实现了两阶段提交,不同的业务场景所写的代码都不一样,复杂度也不一样,因此,这种模式并不能很好地被复用。

    6、总结

    分布式事务,本质上是对多个数据库的事务进行统一控制,按照控制力度可以分为:不控制、部分控制和完全控制。不控制就是不引入分布式事务,部分控制就是各种变种的两阶段提交,包括上面提到的消息事务+最终一致性、TCC模式,而完全控制就是完全实现两阶段提交。部分控制的好处是并发量和性能很好,缺点是数据一致性减弱了,完全控制则是牺牲了性能,保障了一致性,具体用哪种方式,最终还是取决于业务场景。作为技术人员,一定不能忘了技术是为业务服务的,不要为了技术而技术,针对不同业务进行技术选型也是一种很重要的能力

    本文链接:http://www.codeceo.com/article/distributed-transaction.html

    本文作者:码农网 – 吴极心

    展开全文
  • 什么是事务事务(`Transaction`),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元。事务通常由高级数据库操作语言或编程语言(如 SQL,C++ 或 Java)书写...
  • 深入理解分布式事务

    千次阅读 2016-11-11 14:47:58
    我在上一期介绍了spring的事务原理(详情见《深入理解spring事务原理》),Spring事务本质是单机下的事务,是由数据库本身保证的。今天,我将介绍一种比较复杂的事务:分布式事务。 1、什么是分布式事务 ...
  • 深入理解分布式事务(XA及rocketmq事务) 发布时间:2018-04-16 来源:网络 上传者:用户 关键字: 事务 分布式 RocketMq 深入 理解 发表文章 摘要:本文由码农网–吴极心原创,转载请看清文末的转载要求,...
  • 数据库事务和隔离级别的理解

    千次阅读 2019-03-09 10:36:10
    数据库事务和隔离级别的理解 1.事务的概念 ​ 事务指逻辑上的一组操作,组成这组操作的各个单元,要不全部成功,要不全部不成功。 2. MySQL数据库事务操作命令 ​ 直接通过例子来说明 1.事务开始但没有提交 ...
  • @[TOC] 目录 NO1.框架自动提交事务与异常回滚 NO2.控制框架的提交和事务回滚 NO3.AOP+注解实现事务的提交和回滚 NO4.spring事务源码解读
  • 深入理解分布式事务Percolator(一)

    千次阅读 2019-03-15 15:19:45
    什么是分布式事务 假如你是一个先了解过分布式一致性,后接触分布式事务的人,那估计很容易混淆这两个概念。因为本质上都是为了宏观数据上的一致性,那么既然有了分布式一致性协议,比如paxos/raft,为什么还要搞...
  • 理解事务处理、事务处理的隔离级别,和使用JDBC进行事务处理 佟强 http://blog.csdn.net/microtong 2009年12月23日 事务是作为单个逻辑工作单元执行的一系列操作。一个逻辑工作单元必须有四个属性(ACID):原子性...
  • OMID是Yahoo构建在HBase上的一个分布式事务解决方案,用来拓展HBase所不支持跨行跨表级别的事务。其定位目标是OLTP类型的事务。类似的系统也有不少,他们或多或少都借鉴了谷歌的Percolator的思想,而omid则有较大的...
  • 一、什么是事务   MySQL事务只要勇于处理操作量大,复杂度高的数据。 比如:在管理系统中删除一个人员的基本资料,也要删除人员的相关信息,文件,邮箱等等,这些数据库的操作语句就构成了一个事务。一个事务是...
  • 为了保证事务操作的原子性,必须实现基于日志的REDO/UNDO机制:将所有数据的更新操作都写入日志,如果一个事务中的一部分操作已经成功,但以后的操作,由于断电/系统崩溃/其它的软硬件错误而无法继续,则通过回溯...
  • 转载请注明出处: jiq•钦's technical Blog - 季义钦引言:在网上搜了很多关于事务的文章,感觉单独来看都很难看懂,所以综合自己的理解写一篇我自己能理解的关于关系型数据库事务的文章。一、事务特征我们都知道...
  • 彻底理解事务的4个隔离级别

    千次阅读 2017-04-07 09:47:00
    所以一旦事务被提交之后,数据就能够被持久化下来,又因为事务是满足隔离性的,所以,当多个事务同时处理同一个数据的时候,多个事务直接是互不影响的,所以,在多个事务并发操作的过程中,如果控制不好隔离级别,就...
  • 事务

    千次阅读 2019-03-23 17:13:47
    Java事务的类型有三种:JDBC事务、JTA(Java Transaction API)事务、容器事务 1、JDBC事务 JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式:自动提交和手工...
  • 理解事务的一致性和原子性

    千次阅读 2013-12-29 10:33:31
    无奈之下我开始认真地翻书,终于在《数据库系统概念》这本书中找到答案,加上个人的一点理解,觉得这样的解释还算是合理的,发出来与大家共享讨论。 事务:数据库应用中完成单一逻辑功能的操作集合,是一个既...
  • 分布式事务:深入理解什么是2PC、3PC及TCC协议

    万次阅读 多人点赞 2019-01-23 08:48:00
    1导读对于分布式事务的概念,可能还会有很多同学不理解或者理解得不是很深刻的地方,在这篇文章中,作者打算重点给大家先介绍下分布式事务相关的基本概念,诸如2PC、3PC、TC...
  • 个人理解的SpringAOP事务管理

    千次阅读 2017-03-20 21:12:46
    getIsolationLevel:他其他事务所看到的数据变化进行控制。  事务隔离级别:  隔离级别 说明  ISOLATION_DEFAULT 默认级别(大多数数据库来说就是ISOLATION_READ_COMMITTED)  ISOLATION_READ_...
  • 本地事务 本地事务流程 在介绍分布式事务之前,我们先来看看本地事务。...缺乏分布式事务的处理能力。 数据隔离的最小单元由RM(资源管理器决定),开发人员无法决定数据隔离的最小单元。比如:数据库中
  • mysql事务

    千次阅读 2015-01-09 10:08:22
    项目中使用的是mysql数据库,有幸看到《高性能mysql》一书,并且参考其对事务的介绍,结合实际开发对事务进行了测试,主要关注点在事务的隔离级别、innodb_flush_log_at_trx_commit、autocommit参数mysql性能的...
  • 在面试中,基本上都会问到关于数据库的事务问题,如果啥都不会或者只回答到表面的上知识点的话,那面试基本上是没戏了,为了能顺利通过面试,那MySql的事务问题就需要了解,所以就根据网上的资料总结一版Mysql事务的...
  • 例:   类似这样的方法不会回滚 (一个方法出错,另一个方法不会回滚) :   if(userSave){  try {  userDao.save(user);  userCapabilityQuotaDao.save(capabilityQuota);...能力开通接口,开...
  • 在上一篇文章中说到过,Java事务的类型有三种:JDBC事务、JTA(Java Transaction API)事务、容器事务。这是从事务的实现角度区分的,本文从另外一个角度来再次区分一下Java中的事务。 站在事务管理的角度,可以把Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,376
精华内容 47,750
关键字:

对事务的理解能力