精华内容
下载资源
问答
  • 因为事务需要实现ACID,即原子性、一致性、隔离性、持久性,所以需要采用一定的机制来保证,通常采用的是分阶段提交的方式。... 一阶段提交协议相对简单,简单带来的优点就是,它不用再与其他的对象...

    因为事务需要实现ACID,即原子性、一致性、隔离性、持久性,所以需要采用一定的机制来保证,通常采用的是分阶段提交的方式。

       XA:XA协议,规定事务管理器和资源管理器接口,采用二阶段提交协议。

     

    一阶段提交协议

        一阶段提交协议相对简单,如下图:

              

              当然,前提是开启了事务,然后在应用程序发出提交/回滚请求后,数据库执行操作,而后将成功/失败返回给应用程序,程序继续执行。

        一阶段提交协议相对简单,简单带来的优点就是,它不用再与其他的对象交互,节省了判断步骤和时间,所以在性能上是在阶段提交协议中对好的。

     

    二阶段提交协议

        一阶段提交协议有其优点,但缺点也很明显:

    • 数据库确认执行事务的时间较长,出问题的可能性就随之增大。
    • 如果有多个数据源,一阶段提交协议无法协调他们之间的关系。

       所以在一阶段协议的基础上,有了二阶段协议,二阶段协议的好处是添加了一个管理者角色,如下:

           

       很明显,二阶段协议通过将两层变为三层,增加了中间的管理者角色,从而协调多个数据源之间的关系,二阶段提交协议分为两个阶段。

        第一阶段

        

     

    应用程序调用了事务管理器的提交方法,此后第一阶段分为两个步骤:

    • 事务管理器通知参与该事务的各个资源管理器,通知他们开始准备事务。
    • 资源管理器接收到消息后开始准备阶段,写好事务日志并执行事务,但不提交,然后将是否就绪的消息返回给事务管理器(此时已经将事务的大部分事情做完,以后的内容耗时极小)。

        第二阶段

          

     

    第二阶段也分为两个步骤:    

    • 事务管理器在接受各个消息后,开始分析,如果有任意其一失败,则发送回滚命令,否则发送提交命令。
    • 各个资源管理器接收到命令后,执行(耗时很少),并将提交消息返回给事务管理器。

     

        事务管理器接受消息后,事务结束,应用程序继续执行。
        为什么要分两步执行?一是因为分两步,就有了事务管理器统一管理的机会;二尽可能晚地提交事务,让事务在提交前尽可能地完成所有能完成的工作,这样,最后的提交阶段将是耗时极短,耗时极短意味着操作失败的可能性也就降低。

        同时,二阶段提交协议为了保证事务的一致性,不管是事务管理器还是各个资源管理器,每执行一步操作,都会记录日志,为出现故障后的恢复准备依据。
        二阶段提交协议的存在的弊端是阻塞,因为事务管理器要收集各个资源管理器的响应消息,如果其中一个或多个一直不返回消息,则事务管理器一直等待,应用程序也被阻塞,甚至可能永久阻塞。

    展开全文
  • 因为事务需要实现ACID,即原子性、一致性、隔离性、持久性,所以需要采用一定的机制来保证,通常采用的是分阶段提交的方式。 XA:XA协议,规定事务管理器和资源管理...一阶段提交协议相对简单,简单带来的优点就是,...

    因为事务需要实现ACID,即原子性、一致性、隔离性、持久性,所以需要采用一定的机制来保证,通常采用的是分阶段提交的方式。
    XA:XA协议,规定事务管理器和资源管理器接口,采用二阶段提交协议。

    一阶段提交协议

    一阶段提交协议相对简单。当然,前提是开启了事务,然后在应用程序发出提交/回滚请求后,数据库执行操作,而后将成功/失败返回给应用程序,程序继续执行。
    一阶段提交协议相对简单,简单带来的优点就是,它不用再与其他的对象交互,节省了判断步骤和时间,所以在性能上是在阶段提交协议中对好的。

    二阶段提交协议

    一阶段提交协议有其优点,但缺点也很明显:

    数据库确认执行事务的时间较长,出问题的可能性就随之增大。
    如果有多个数据源,一阶段提交协议无法协调他们之间的关系。
    所以在一阶段协议的基础上,有了二阶段协议,二阶段协议的好处是添加了一个管理者角色,如下:
    在这里插入图片描述
    很明显,二阶段协议通过将两层变为三层,增加了中间的管理者角色,从而协调多个数据源之间的关系,二阶段提交协议分为两个阶段。
    为什么要分两步执行?一是因为分两步,就有了事务管理器统一管理的机会;二尽可能晚地提交事务,让事务在提交前尽可能地完成所有能完成的工作,这样,最后的提交阶段将是耗时极短,耗时极短意味着操作失败的可能性也就降低。
    同时,二阶段提交协议为了保证事务的一致性,不管是事务管理器还是各个资源管理器,每执行一步操作,都会记录日志,为出现故障后的恢复准备依据。
    二阶段提交协议的存在的弊端是阻塞,因为事务管理器要收集各个资源管理器的响应消息,如果其中一个或多个一直不返回消息,则事务管理器一直等待,应用程序也被阻塞,甚至可能永久阻塞。

    手写XA,理解其原理

    事务管理器

    public class TM {
    
        public  void execute(Connection accountConn,Connection redConn) throws SQLException {
            //打印XA的事务日志 true 代表打印
            boolean logXaCommands = true;
            //获取RM1 的接口实例
            XAConnection xaConn1 = new MysqlXAConnection((com.mysql.jdbc.ConnectionImpl) accountConn, logXaCommands);
            XAResource rm1 = xaConn1.getXAResource();
    
            //获取RM2 的接口实例
            XAConnection xaConn2 = new MysqlXAConnection((com.mysql.jdbc.ConnectionImpl) redConn, logXaCommands);
            XAResource rm2 = xaConn2.getXAResource();
    
    
            //生成一个全局事务ID
            byte[] globalid = "agan12345".getBytes();
            int formatId = 1;
            try {
                //TM 把rm1的事务分支id,注册到全局事务ID
                byte[] bqual1 = "b00001".getBytes();
                Xid xid1 = new MysqlXid(globalid, bqual1, formatId);
                //start...end 开始 结束 rm1的本地事务
                rm1.start(xid1, XAResource.TMNOFLAGS);
                //模拟购物买一个物品,用余额支付90㡰
                String sql="update capital_account set balance_amount=balance_amount-90 where user_id=1";
                PreparedStatement ps1 = accountConn.prepareStatement(sql);
                ps1.execute();
                rm1.end(xid1, XAResource.TMSUCCESS);
    
    
                //TM 把rm2的事务分支id,注册到全局事务ID
                byte[] bqual2 = "b00002".getBytes();
                Xid xid2 = new MysqlXid(globalid, bqual2, formatId);
                //start...end 开始 结束 rm2的本地事务
                rm2.start(xid2, XAResource.TMNOFLAGS);
                //模拟购物一个物品,用红包支付10元。
                sql="update red_packet_account set balance_amount=balance_amount-10 where user_id=1";
                PreparedStatement ps2 = redConn.prepareStatement(sql);
                ps2.execute();
                rm2.end(xid2, XAResource.TMSUCCESS);
    
                //2阶段提交中得第一个阶段:准备提交
                int rm1_prepare = rm1.prepare(xid1);
                int rm2_prepare = rm2.prepare(xid2);
    
                //2阶段提交中得第二个阶段:真正提交
                if (rm1_prepare == XAResource.XA_OK && rm2_prepare == XAResource.XA_OK) {
    
                    boolean onePhase = false;
                    rm1.commit(xid1, onePhase);//提交事务
                    rm2.commit(xid2, onePhase);//提交事务
                } else {//全部回滚
                    rm1.rollback(xid1);
                    rm1.rollback(xid2);
                }
            } catch (XAException e) {
                // 如果出现异常,也要进行回滚
                e.printStackTrace();
            }
        }
    }
    

    两个不同的数据源,红包账户和余额账户扣钱

    public class AP {
    
        public Connection getRmAccountConn(){
    
            try {
                Connection conn = DriverManager.getConnection("jdbc:mysql://192.168.0.138:3307/xa_account?characterEncoding=utf8&useSSL=false&autoReconnect=true", "root", "agan");
                return conn;
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public Connection getRmRedConn(){
            try {
                Connection conn = DriverManager.getConnection("jdbc:mysql://192.168.0.138:3308/xa_red_account?characterEncoding=utf8&useSSL=false&autoReconnect=true", "root", "agan");
                return conn;
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    测试代码:

    public class XaTest {
    
        AP ap=new AP();
        TM tm=new TM();
    
    
        @Test
        public void test(){
            try {
                tm.execute(ap.getRmAccountConn(),ap.getRmRedConn());
            } catch (SQLException e) {
                e.printStackTrace();
            }
    
        }
    }
    

    使用Atomikos

    第一步:导入核心的依赖包
    、、、 org.springframework.boot spring-boot-starter-jta-atomikos

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
    </dependency>
    

    、、、

    第二步: 改配置多数据域
    配置atomikos 事务管理器,并配置druid作为数据源并且进行监控 application.properties 文件中配置druid的2个数据源。

    ##account表数据库配置
    spring.atomikos.datasource.account.max-pool-size=25
    spring.atomikos.datasource.account.min-pool-size=3
    spring.atomikos.datasource.account.max-lifetime=20000
    spring.atomikos.datasource.account.borrow-connection-timeout=10000
    spring.atomikos.datasource.account.unique-resource-name=account
    spring.atomikos.datasource.account.xa-properties.url=jdbc:mysql://192.168.0.138:3307/xa_account?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
    spring.atomikos.datasource.account.xa-properties.username=root
    spring.atomikos.datasource.account.xa-properties.password=agan
    spring.atomikos.datasource.account.xa-properties.driverClassName=com.mysql.jdbc.Driver
    # 初始化大小,最小,最大
    spring.atomikos.datasource.account.xa-properties.initialSize=10
    spring.atomikos.datasource.account.xa-properties.minIdle=20
    spring.atomikos.datasource.account.xa-properties.maxActive=100
    ## 配置获取连接等待超时的时间
    spring.atomikos.datasource.account.xa-properties.maxWait=60000
    # 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
    spring.atomikos.datasource.account.xa-properties.timeBetweenEvictionRunsMillis=60000
    # 配置一个连接在池中最小生存的时间,单位是毫秒
    spring.atomikos.datasource.account.xa-properties.minEvictableIdleTimeMillis=300000
    spring.atomikos.datasource.account.xa-properties.testWhileIdle=true
    spring.atomikos.datasource.account.xa-properties.testOnBorrow=false
    spring.atomikos.datasource.account.xa-properties.testOnReturn=false
    # 打开PSCache,并且指定每个连接上PSCache的大小
    spring.atomikos.datasource.account.xa-properties.poolPreparedStatements=true
    spring.atomikos.datasource.account.xa-properties.maxPoolPreparedStatementPerConnectionSize=20
    # 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
    spring.atomikos.datasource.account.xa-properties.filters=stat,slf4j,wall
    spring.atomikos.datasource.account.xa-data-source-class-name=com.alibaba.druid.pool.xa.DruidXADataSource
    
    #------------------------------ 分隔符-------------------------------------
    ##redpacket表数据库配置
    spring.atomikos.datasource.redpacket.max-pool-size=25
    spring.atomikos.datasource.redpacket.min-pool-size=3
    spring.atomikos.datasource.redpacket.max-lifetime=20000
    spring.atomikos.datasource.redpacket.borrow-connection-timeout=10000
    spring.atomikos.datasource.redpacket.unique-resource-name=redpacket
    spring.atomikos.datasource.redpacket.xa-properties.url=jdbc:mysql://192.168.0.138:3308/xa_red_account?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
    spring.atomikos.datasource.redpacket.xa-properties.username=root
    spring.atomikos.datasource.redpacket.xa-properties.password=agan
    spring.atomikos.datasource.redpacket.xa-properties.driverClassName=com.mysql.jdbc.Driver
    spring.atomikos.datasource.redpacket.xa-properties.initialSize=10
    spring.atomikos.datasource.redpacket.xa-properties.minIdle=20
    spring.atomikos.datasource.redpacket.xa-properties.maxActive=100
    spring.atomikos.datasource.redpacket.xa-properties.maxWait=60000
    spring.atomikos.datasource.redpacket.xa-properties.timeBetweenEvictionRunsMillis=60000
    spring.atomikos.datasource.redpacket.xa-properties.minEvictableIdleTimeMillis=300000
    spring.atomikos.datasource.redpacket.xa-properties.testWhileIdle=true
    spring.atomikos.datasource.redpacket.xa-properties.testOnBorrow=false
    spring.atomikos.datasource.redpacket.xa-properties.testOnReturn=false
    spring.atomikos.datasource.redpacket.xa-properties.poolPreparedStatements=true
    spring.atomikos.datasource.redpacket.xa-properties.maxPoolPreparedStatementPerConnectionSize=20
    # 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
    spring.atomikos.datasource.redpacket.xa-properties.filters=stat,slf4j,wall
    spring.atomikos.datasource.redpacket.xa-data-source-class-name=com.alibaba.druid.pool.xa.DruidXADataSource
    
    
    #jta相关参数配置
    #spring.jta.transaction-manager-id=txManager
    #spring.jta.log-dir=transaction-logs-agan
    
    
    logging.level.root=INFO
    

    第三步:将配置的数据库连接信息,注入数据源,并且设置druid的监控中心。
    MybatisConfiguration 的目的是配置DataSource

    @Configuration
    @EnableConfigurationProperties
    @EnableTransactionManagement(proxyTargetClass = true)
    public class MybatisConfiguration {
        /**
         * account数据库配置前缀.
         */
        final static String ACCOUNT_PREFIX = "spring.atomikos.datasource.account";
        /**
         * redpacket数据库配置前缀.
         */
        final static String REDPACKET_PREFIX = "spring.atomikos.datasource.redpacket";
    
        /**
         * The constant logger.
         */
        final static Logger logger = LoggerFactory.getLogger(MybatisConfiguration.class);
    
        /**
         * 配置druid显示监控统计信息
         * 开启Druid的监控平台 http://localhost:8080/druid
         *
         * @return servlet registration bean
         */
        @Bean
        public ServletRegistrationBean druidServlet() {
            logger.info("Init Druid Servlet Configuration ");
            ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
            // IP白名单,不设默认都可以
    //        servletRegistrationBean.addInitParameter("allow", "192.168.2.25,127.0.0.1");
            // IP黑名单(共同存在时,deny优先于allow)
            servletRegistrationBean.addInitParameter("deny", "192.168.1.100");
            //控制台管理用户
            servletRegistrationBean.addInitParameter("loginUsername", "root");
            servletRegistrationBean.addInitParameter("loginPassword", "agan");
            //是否能够重置数据 禁用HTML页面上的“Reset All”功能
            servletRegistrationBean.addInitParameter("resetEnable", "false");
            return servletRegistrationBean;
        }
    
        /**
         * 注册一个filterRegistrationBean
         *
         * @return filter registration bean
         */
        @Bean
        public FilterRegistrationBean filterRegistrationBean() {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
            //添加过滤规则
            filterRegistrationBean.addUrlPatterns("/*");
            //添加不需要忽略的格式信息
            filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
            return filterRegistrationBean;
        }
    
        /**
         * 配置Account数据库的数据源
         *
         * @return the data source
         */
        @Bean(name = "AccountDataSource")
        @ConfigurationProperties(prefix = ACCOUNT_PREFIX)  // application.properties中对应属性的前缀
        public DataSource accountDataSource() {
            return new AtomikosDataSourceBean();
        }
    
        /**
         * 配置RedPacket数据库的数据源
         *
         * @return the data source
         */
        @Bean(name = "RedPacketDataSource")
        @ConfigurationProperties(prefix = REDPACKET_PREFIX)  // application.properties中对应属性的前缀
        public DataSource redPacketDataSource() {
            return new AtomikosDataSourceBean();
        }
    }
    
    

    AccountDataSourceConfiguration 作用:配置account的数据源的sessionfactory ,同时关联mybaits RedAccountDataSourceConfiguration 作用:配置RedAccount的数据源的sessionfactory ,同时关联mybaits

    @Configuration
    @MapperScan(basePackages = {"com.agan.dtp.atomikos.mapper.account.mapper"}, sqlSessionFactoryRef = "accountSqlSessionFactory")
    public class AccountDataSourceConfiguration {
        /**
         * The constant MAPPER_XML_LOCATION.
         */
        public static final String MAPPER_XML_LOCATION = "classpath*:com/agan/dtp/atomikos/mapper/account/mapper/*.xml";
    
        /**
         * The Open plat form data source.
         */
        @Autowired
        @Qualifier("AccountDataSource")
        DataSource accountDataSource;
    
        /**
         * 配置Sql Session模板
         *
         * @return the sql session template
         * @throws Exception the exception
         */
        @Bean
        public SqlSessionTemplate springSqlSessionTemplate() throws Exception {
            return new SqlSessionTemplate(accountSqlSessionFactory());
        }
    
        /**
         * 配置SQL Session工厂
         *
         * @return the sql session factory
         * @throws Exception the exception
         */
        @Bean
        public SqlSessionFactory accountSqlSessionFactory() throws Exception {
            SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
            factoryBean.setDataSource(accountDataSource);
            //指定XML文件路径
            factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MAPPER_XML_LOCATION));
            return factoryBean.getObject();
        }
    }
    
    

    第四步:service体验 atomikos
    PayServiceImpl 作用:模拟下订单的同时扣除,账户余额,红包余额的钱。

    @Service
    public class PayServiceImpl implements PayService {
    
        @Autowired
        private CapitalAccountMapper capitalAccountMapper;
        @Autowired
        private RedPacketAccountMapper redPacketAccountMapper;
    
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void pay(int userId,int account, int redAccount) {
            CapitalAccount ca=new CapitalAccount();
            ca.setUserId(userId);
            CapitalAccount capitalDTO=this.capitalAccountMapper.selectOne(ca);
            System.out.println(capitalDTO);
            //账户余额扣除
            capitalDTO.setBalanceAmount(capitalDTO.getBalanceAmount()-account);
            this.capitalAccountMapper.updateByPrimaryKey(capitalDTO);
    
            RedPacketAccount red= new RedPacketAccount();
            red.setUserId(userId);
            RedPacketAccount redDTO=this.redPacketAccountMapper.selectOne(red);
            System.out.println(redDTO);
            //红包余额扣除
            redDTO.setBalanceAmount(redDTO.getBalanceAmount()-redAccount);
            this.redPacketAccountMapper.updateByPrimaryKey(redDTO);
            //int n=9/0;
        }
    }
    

    第五步: junit 测试

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class AtomikosTests {
    
        @Autowired
        PayService payService;
    
        @Test
        //@Transactional
        public void contextLoads() {
            try {
               this.payService.pay(1,10,10);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    第六步: 查看Atomikos的日志
    1.如何测试atomikos的事务运行结果? 查看Atomikos的日志,默认情况下,在项目的根目录下会自动创建transaction-logs文件夹,每个Atomikos实例都会有一个全局ID,这个ID为Atomikos运行机器的IP地址; 这个唯一ID会自动关联多个数据库的事务信息,也就是会关联分支事务id.

    2.atomikos日志的自定义配置 spring.jta.log-dir=transaction-logs-agan

    展开全文
  • 阶段提交协议 三阶段提交主要解决了二阶段提交的缺点。... 优点:三阶段提交协议可以有效避免阻塞情况的出现,因为不管是协调者也好,还是参与者也好,都增加了超时机制。 缺点:相对于2PC,3P...

    三阶段提交协议

            三阶段提交主要解决了二阶段提交的缺点。

          (1)【事务管理器】及【数据库事务参与者】都增加了超时机制。在二阶段提交协议中,会出现无限期等待阻塞的情况。

          (2)增加了一个新阶段。相当于把之前的准备阶段拆分成两个新的阶段--------CanCommit阶段与PreCommit阶段。

    3

            优点:三阶段提交协议可以有效避免阻塞情况的出现,因为不管是协调者也好,还是参与者也好,都增加了超时机制。

            缺点:相对于2PC,3PC增加了网络通讯次数,实现起来比较复杂。

    展开全文
  • 一致性协议

    2017-12-11 14:57:59
    将一个事务的处理过程分为了投票和执行个阶段,其核心是对每个事务都采用先尝试后提交的处理方式,可将二阶段提交看作一个强一致性的算法。 优点:原理简单,实现方便 缺点:同步阻塞、单点问题、数据不一致、...
    1. 二阶段提交:2PC
      将一个事务的处理过程分为了投票和执行两个阶段,其核心是对每个事务都采用先尝试后提交的处理方式,可将二阶段提交看作一个强一致性的算法。

      这里写图片描述
      这里写图片描述
      优点:原理简单,实现方便
      缺点:同步阻塞、单点问题、数据不一致、太过保守
      ① 同步阻塞:在二阶段提交的执行过程中,所有参与该事务操作的逻辑都处于阻塞状态,也就是说,各个参与者在等待其他参与者响应的过程中,将无法进行任何其他操作。
      ② 单点问题:协调者一旦出现问题,整个二阶段提交流程将无法运行
      ③ 数据不一致:在阶段二执行事务提交的时候,当协调者向所有的参与者发送Commit请求之后,发生了局部网络异常,导致最终只有部分参与者收到了Commit请求。于是出现数据不一致现象。
      ④ 太过保守:如果在协调者指示参与者进行事务提交询问的过程中,参与者出现故障而导致协调者始终无法获取到所有参与者的响应信息的话,这时协调者只能依靠其自身的超时机制来判断是否需要中断事务。任意一个节点的失败都会导致整个事务的失败。

    2. 三阶段提交:3PC
      将二阶段提交协议的“提交事务请求”过程一分为二,形成由CanCommit,PreCommit,DoCommit三个阶段的事务处理协议。
      ① CanCommit:事务询问、各参与者向协调者反馈事务询问的响应
      ② PreCommit:执行事务预提交(发送预提交请求、事务预提交、各参与者向协调者反馈事务执行的响应)、中断事务(发送中断请求、中断事务)
      ③ DoCommit:执行提交(发送提交请求、事务提交、反馈事务提交结果、完成事务)、中断事务(发送中断请求、事务回滚、反馈事务回滚结果、中断事务)

      一旦进入阶段三,可能存在以下两种故障:
      ① 协调者出现问题
      ② 协调者和参与者之间的网络出现故障

      无论哪种情况,最终都会导致参与者无法及时接收到来自协调者的DoCommit或是abort请求,针对这样的异常情况,参与者都会在等待超时之后,继续进行事务提交。
      优点:较之2PC,降低了参与者的阻塞范围,并且能够在出现单点故障后继续达成一致。
      缺点:在参与者接收到PreCommit消息后,如果网络出现分区,此时协调者所在的节点和参与者无法进行正常的网络通信,在这种情况下,该参与者依然会进行事务的提交,这必然出现数据的不一致性。

    3. Paxos算法
      Paxos是一种基于消息传递且具有高度容错特性的一致性算法,是目前公认的解决分布式一致性问题最有效的算法之一。

    展开全文
  • 分布式一致性协议-2PC与3PC(三)

    万次阅读 2018-05-16 22:03:03
    一、分布式一致性 一个事务需要跨多个分布式节点,又要保持事务的ACID特性,需要引入协调者来统一调度所有分布式...二阶段提交:将事务分成了投票和执行个阶段。 优点:原理简单 缺点:单点问题、同步阻塞、...
  • 一、分布式一致性 一个事务需要跨多个分布式节点,又要保持事务的ACID特性,需要引入协调者来统一调度所有...二阶段提交:将事务分成了投票和执行个阶段。 优点:原理简单 缺点:单点问题、同步阻塞、无限期...
  • 2PC既两阶段提交,又叫做 XA Transactions,MySQL从5.5版本开始支持,SQL Server 2005 开始支持,Oracle 7 开始支持,它的优点是强一直性,缺点则是降低了可用性,这里由于本篇博客以实践为主就不过多赘述理论知识了...
  • 漫谈2PC和3PC相关理论

    2020-08-04 20:00:54
    漫谈2PC和3PC相关理论1.概念1.2PC2.3PC2PC1.基本原理2.执行过程1....2PC是两阶段提交(two-phase commit)的简称,是一个非常经典的强一致性、中心化的原子提交协议,所以又称为两阶段提交协议(two-phase
  • 全局事务(DTP模型) --标准的分布式事务 全局事务(DTP模型) --XA协议 mysql oracle 都是实现了XA协议 两阶段提交(Two Phase ...全局事务下,全局事务管理器(TM) 通过XA接口适用两阶段提交协议(2PC) 与资...
  • 分布式事务

    2020-10-01 11:50:38
    commit二、分布式事务解决方案2.1 全局事务(DTP 模型)2.1.1 XA 规范2.1.2 XA 规范流程2.1.3 基于XA协议两阶段提交方案2.2 基于可靠消息服务(事务消息中间件)2.3 基于本地消息表2.4 TCC2.4.1 TCC 机制2.4.2 TCC...
  • 数据库 - 分布式事务

    2019-03-06 18:03:38
    1.两阶段提交协议 方案:分为准备阶段与提交阶段,等待所有参与者准备完成后再提交。 优点:基于该协议,事务管理器能最大限度保证跨数据库事务的原子性,是分布式系统环境下最严格的实现方案。 缺点:性能问题...
  • 什么是分布式事务 如今在分布式技术盛行下,许多公司都已经在使用分布式技术了,虽然分布式技术给我们项目带来了三高(高...两阶段提交协议(Two Phase Commitment Protocol)中,基于数据库XA协议(mysql5.0.3支持此协议),
  • 分布式事务实现方式两阶段提交协议 两个角色:协调者和参与者 协调者:负责调度参与者的行为,并最终决定参与者是有要把事务真正提交。(统一调度所有分布式节点的执行逻辑。),在具体实现当中常称为全局事务管理...
  • 基本概念 本地事务 事务由资源管理器(如DBMS)本地管理 ...优点:严格的ACID缺点:不具备分布事务处理能力 ...两阶段提交 优点 准备后,仍可提交或回滚准备时,一致性检查必须OK准备后,事务
  • 企业级分布式事务

    2016-12-25 11:06:00
    基本概念 本地事务 事务由资源管理器(如DBMS)本地管理 优点:严格的ACID 缺点:不具备分布事务处理能力 全局事务(DTP模型) TX协议:应用或应用服务器与...两阶段提交 优点 准备后,仍可提交或回滚 准备时,...
  • 2PC和3PC分布式事务

    2020-07-22 16:51:33
    两阶段提交(2PC) 优点:尽量保证了数据的强一致性,各大主流数据库本身支持(XA协议) 缺点: 单点问题:阶段一完成以后,事务管理器宕机,导致无法进行阶段二,资源管理器一直处于阻塞状态。 同步阻塞:阶段...
  • 两阶段提交过程缺点3.三阶段提交过程4. paxos协议过程2. 消息队列优点两种模式常用的消息队列RabbitMQActiveMQRocketMQKafka如何保证消息队列是高可用的如何保证消息不被重复消费如何保证消费的可靠性传输(以...
  • 事务 | Spring Cloud 分布式事务管理 LCN、GTX、ByteTCC

    万次阅读 多人点赞 2018-03-18 21:03:04
    事务 | Spring Cloud 分布式事务管理 LCN、GTX、ByteTCC 在微服务如火如荼的情况下,越来越多的项目开始尝试改造成微服务架构,微服务...基于XA协议两阶段提交 消息事务+最终一致性 TCC编程模式 具体实现 LCN B...
  • 里的数据,为了保证数据准确性和一致性,我们大都使用分布式事务来实现(非常经典的两阶段提交协议)。    分布式事务最大的优点就是简化应用开发,对于时间紧迫并且性能要求不高的系统可以大大的提高开发效率,这...
  • 前言分布式微服务中事务问题,是一直困扰着...无侵入型的方案有基于数据库的XA协议两阶段提交,它的优点对业务无侵入,缺点也很明显;数据库必须支持XA协议,且支持XA协议对性能的影响很大,因为它会造成事务资...
  • 在微服务如火如荼的情况下,越来越多的项目开始尝试改造成微服务架构,微服务即带来了项目开发的方便性,又提高了运维难度以及网络不可靠的概率. ... 基于XA协议两阶段提交 消息事务+最终一致性 ...
  • Spring Cloud 分布式事务管理 在微服务如火如荼的情况下,越来越多的项目开始尝试改造成微服务架构,微服务即带来了项目开发的方便性,又提高了运维难度以及网络不...基于XA协议两阶段提交 消息事务+最终一致性...
  • Spring Cloud 分布式事务管理 在微服务如火如荼的情况下,越来越多的项目开始尝试改造成微服务架构,微服务即带来了项目开发的方便性,又提高了运维难度以及网络不...基于XA协议两阶段提交 消息事务+最终一致性...
  • 欢迎关注头条号:老顾聊技术精品原创技术分享,知识的组装工前言分布式微服务中事务问题,是一直...无侵入型的方案有基于数据库的XA协议两阶段提交,它的优点对业务无侵入,缺点也很明显;数据库必须支持XA协议,...
  • 欢迎关注头条号:老顾聊技术精品原创技术分享,知识的组装工前言分布式微服务中事务问题,是一直...无侵入型的方案有基于数据库的XA协议两阶段提交,它的优点对业务无侵入,缺点也很明显;数据库必须支持XA协议,...

空空如也

空空如也

1 2 3
收藏数 50
精华内容 20
关键字:

两阶段提交协议优点