模拟分布式事务

已于 2023-02-24 14:27:53 修改
阅读量98 收藏
点赞数
分类专栏： 大数据 文章标签： 分布式 java 数据库
于 2023-02-19 16:13:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluedraam_pp/article/details/129111304
版权

事务是什么？

一个完整的，不可分割的操作单元
要么都做完，要么都不成功

什么是分布式事务

分布式事务在分布式系统中的事务。它不是单机中完成操作单元，在一个事务中可能有若干个服务器参与。

两阶段提交

两阶段提交就是一个分布式事务的解决方案。

第一个阶段：提交阶段，所有的参与者发送本地操作是否完成，如果完成则给协调者发送操作完成的消息，否则发送失败的消息，
协调者等待参与者失败或者成功的消息，或者等待超时。第一阶段结束。
第二阶段：执行阶段。当协调者收到所有参与者执行成功的消息后，发送给参与者可以完成本地操作。
如果协调者收到一个参与者执行失败的消息或者超时，则发送给参与者回滚本地操作的消息。

使用 NIO 自己实现最简单的两阶段提交。

下面是协调者的代码：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @className: Coordinator
 * @Description:
 * 通信的协议：
 * 发送 32 bit ，也就是一个 int 类型的数值，0000 0000 0000 0000 0000 0000 0000 0000
 * 第一位置上代表身份，1 代表协调者，0 代表参与者
 * 参与者： 0010 代表本地 checkpoint 结束，
 *        0000 代表失败
 * 协调者： 0001 代表回滚
 *        0011 代表所有的服务器上的事务都成功了。
 *
 * @Author: wangyifei
 * @Date: 2023/2/19 8:42
 */
public class Coordinator {
    private static Logger logger = LoggerFactory.getLogger(Coordinator.class);

    public static void main(String[] args) {
        try {
            List<ParticipantNode> participants = new ArrayList<>();
            int participantsReady = 3 ;
            ServerSocketChannel ssc = ServerSocketChannel.open();
            ssc.bind(new InetSocketAddress(6666));
            Selector selector = Selector.open();
            ssc.configureBlocking(false);
            ssc.register(selector , 0).interestOps(SelectionKey.OP_ACCEPT);
            Set<SelectionKey> selectionKeys = null ;
            Iterator<SelectionKey> iterator = null ;
            while(true){
                selector.select();
                selectionKeys = selector.selectedKeys();
                iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey next = iterator.next();
                    if(next.isAcceptable()){
                        ServerSocketChannel channel = (ServerSocketChannel)next.channel();
                        SocketChannel accept = channel.accept();
                        if(Objects.isNull(accept)){
                            continue;
                        }
                        accept.configureBlocking(false);
                        accept.register(selector , 0).interestOps(SelectionKey.OP_READ);
                        String[] IpAndPort = ParticipantUtils.getIpAndPort(accept.getRemoteAddress().toString());
                        participants.add(new ParticipantNode(IpAndPort[0] , IpAndPort[1] , System.currentTimeMillis()));
                        System.out.println("accept");
                    }else if(next.isReadable()){
                        SocketChannel channel = (SocketChannel)next.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(32);
                        int read = channel.read(buffer);
                        buffer.flip();
                        long aLong = buffer.getLong();
                        long identity = ParseMsgUtils.getIdentity(aLong);
                        if(identity == 0L){
                            String[] ipAndPort = ParticipantUtils.getIpAndPort(channel.getRemoteAddress().toString());

                            if(ParseMsgUtils.getMsg(aLong) == ParseMsgUtils.PARTICIPANT_LOCAL_TX_SUCCESS){
                                ParticipantUtils.setParticipantStatus(participants , ipAndPort[0] , ipAndPort[1] , (byte)1);
                                System.out.println("ip(" + ipAndPort[0] + ") and (" + ipAndPort[1] + ") has commited success");
                            }else if(ParseMsgUtils.getMsg(aLong) == ParseMsgUtils.PARTICIPANT_LOCAL_TX_FAILED){
                                ParticipantUtils.setParticipantStatus(participants , ipAndPort[0] , ipAndPort[1] , (byte)0);
                                System.out.println("ip(" + ipAndPort[0] + ") and (" + ipAndPort[1] + ") has commited failed");
                            }
                        }
//                        if( 3L == ParticipantUtils.getCommitedParticipantCnt(participants)){
//                            ByteBuffer writeBuffer = MsgBuilder.builderCoordinatorAllCommited();
//                            writeBuffer.flip();
//                            System.out.println("all local tx finished");
//                            channel.write(writeBuffer);
//                        }
                        if(read < 0){
                            next.cancel();
                        }
                        channel.register(selector , 0).interestOps(SelectionKey.OP_WRITE);

                    }else if(next.isWritable()){
                        SocketChannel channel = (SocketChannel)next.channel();
                        if( 3L == ParticipantUtils.getCommitedParticipantCnt(participants)){
                            ByteBuffer writeBuffer = MsgBuilder.builderCoordinatorAllCommited();
                            writeBuffer.flip();
                            channel.write(writeBuffer);
                        }
                        channel.register(selector,0).interestOps(SelectionKey.OP_READ);
                    }
                }
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是参与者代码：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Objects;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @className: Participant
 * @Description:
 * @Author: wangyifei
 * @Date: 2023/2/19 8:43
 */
public class Participant {
    private static Logger logger = LoggerFactory.getLogger(Participant.class);

    public static void main(String[] args) {
        try {
            InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
            SocketChannel sc = SocketChannel.open(inetSocketAddress);
            sc.configureBlocking(false);
            Selector selector = Selector.open();
            SelectionKey register = sc.register(selector, 0);
            register.interestOps(SelectionKey.OP_WRITE);
            Scanner scanner = new Scanner(System.in);
            while(true){
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey next = iterator.next();
                    if (next.isReadable()) {
                        SocketChannel channel = (SocketChannel)next.channel();
                        System.out.println("read in , channel is " + channel);
                        if (Objects.isNull(channel)) {
                            continue;
                        }
                        ByteBuffer buffer = ByteBuffer.allocate(32);
                        channel.read(buffer);
                        buffer.flip();
                        long aLong = buffer.getLong();
                        System.out.println(aLong);
                        if(ParseMsgUtils.COORDINATOR_ALL_COMMITED == aLong){
                            System.out.println("all participant has finished local tx , and execution");
                        }
                    }else if(next.isWritable()){
                        System.out.println("input:");
                        scanner.nextLine();
                        SocketChannel channel = (SocketChannel)next.channel();
                        ByteBuffer writeBuffer = ByteBuffer.allocate(32);
                        ByteBuffer buffer = MsgBuilder.builderCommit();
                        buffer.flip();
                        channel.write(buffer);
                        register.interestOps(SelectionKey.OP_READ);
                    }

                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



import java.nio.ByteBuffer;

/**
 * @className: MsgBuilder
 * @Description: 实现消息的构建
 * @Author: wangyifei
 * @Date: 2023/2/19 11:29
 */
public class MsgBuilder {
    public static ByteBuffer builderCommit(){
        return builder(ParseMsgUtils.PARTICIPANT_LOCAL_TX_SUCCESS);
    }
    public static ByteBuffer builderFailed(){
        return builder(ParseMsgUtils.PARTICIPANT_LOCAL_TX_FAILED);
    }
    public static ByteBuffer builderCoordinatorAllCommited(){
        return builder(ParseMsgUtils.COORDINATOR_ALL_COMMITED);
    }
    public static ByteBuffer builderCoordinatorAllRollup(){
        return builder(ParseMsgUtils.COORDINATOR_ALL_ROLLUP);
    }
    public static ByteBuffer builder(long input){
        ByteBuffer allocate = ByteBuffer.allocate(32);
        return allocate.putLong(input);
    }
}


/**
 * @className: ParseMsgUtils
 * @Description: 对消息进行解析
 * @Author: wangyifei
 * @Date: 2023/2/19 9:46
 */
public class ParseMsgUtils {
    private static long IDENTITY_POSITION = (1<<0);
    private static long MSG_POSITION = (
            1<<1 | 1<<2 | 1<<3
            );
    /**
     * participent 执行本地事务失败
     * */
    public static long PARTICIPANT_LOCAL_TX_FAILED = 0x0000000000000000;
    public static long PARTICIPANT_LOCAL_TX_SUCCESS = 0x0000000000000002;
    public static long COORDINATOR_ALL_COMMITED = 0x0000000000000003;
    public static long COORDINATOR_ALL_ROLLUP = 0x0000000000000001;

    public static long getIdentity(long msg ){
        return msg&IDENTITY_POSITION;
    }
    public static long getMsg(long msg){
        return (msg&MSG_POSITION) ;
    }

    public static void main(String[] args) {
        System.out.println(getIdentity(11L) == 1L);
        System.out.println(getIdentity(10L) == 0L);
        // 0
        System.out.println(getMsg(0x0000000000000000) == PARTICIPANT_LOCAL_TX_FAILED);
        System.out.println(getMsg(0x0000000000000002) == PARTICIPANT_LOCAL_TX_SUCCESS);
    }
}




import java.util.Objects;

/**
 * @className: ParticipantNode
 * @Description:代表参与者的 bean 类
 * 记录参与的信息
 * @Author: wangyifei
 * @Date: 2023/2/19 9:35
 */
public class ParticipantNode {
    private String IP ;
    private String port ;
    private long lastestTouchTimestamp ;
    private long timeout;
    private byte txStatus ;

    public byte getTxStatus() {
        return txStatus;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ParticipantNode that = (ParticipantNode) o;
        return Objects.equals(IP, that.IP) && Objects.equals(port, that.port);
    }

    @Override
    public int hashCode() {
        return Objects.hash(IP, port);
    }

    public void setTxStatus(byte txStatus) {
        this.txStatus = txStatus;
    }

    public ParticipantNode(String IP, String port, long lastestTouchTimestamp, long timeout) {
        this.IP = IP;
        this.port = port;
        this.lastestTouchTimestamp = lastestTouchTimestamp;
        this.timeout = timeout;
    }
    public ParticipantNode(String IP, String port, long timeout) {
        this(IP, port , 0 , timeout);
    }

    public String getIP() {
        return IP;
    }

    public void setIP(String IP) {
        this.IP = IP;
    }

    public String getPort() {
        return port;
    }

    public void setPort(String port) {
        this.port = port;
    }

    public long getLastestTouchTimestamp() {
        return lastestTouchTimestamp;
    }

    public void setLastestTouchTimestamp(long lastestTouchTimestamp) {
        this.lastestTouchTimestamp = lastestTouchTimestamp;
    }

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }

    @Override
    public String toString() {
        return "ParticipantNode{" +
                "IP='" + IP + '\'' +
                ", port='" + port + '\'' +
                ", txStatus=" + txStatus +
                '}';
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;

/**
 * @className: ParticipantUtils
 * @Description: 对参与者进行操作的工具类
 * @Author: wangyifei
 * @Date: 2023/2/19 10:45
 */
public class ParticipantUtils {
    public static String[] getIpAndPort(String input){
        String[] split = input.split(":");
        split[0] = split[0].replace("/","") ;
        return split ;
    }
    public static void setParticipantStatus(List<ParticipantNode> list
            , String ip , String port , byte status ){
        if(Objects.isNull(list) || list.isEmpty()){
            throw new RuntimeException("list is empty");
        }
        list.stream().filter(x -> {
            boolean rs = (x.getIP().equals(ip) && x.getPort().equals(port));
            return rs ;
        }).forEach(x->{
            x.setTxStatus(status);
        });
    }
    public static long getCommitedParticipantCnt(List<ParticipantNode> list){
        long count = list.stream().filter(x->x.getTxStatus()==(byte) 1).count();
        return count ;
    }
    public static void main(String[] args) {
        List<ParticipantNode> list = new ArrayList<>();
        list.add(new ParticipantNode("127.0.0.1" , "9999" , System.currentTimeMillis()));
        list.add(new ParticipantNode("127.0.0.1" , "8888" , System.currentTimeMillis()));
        list.add(new ParticipantNode("127.0.0.1" , "7777" , System.currentTimeMillis()));
        setParticipantStatus(list , "127.0.0.1" , "8888" , (byte) 1);
        list.forEach(x -> {
            System.out.println(x);
        });
        for (String s : getIpAndPort("/127.0.0.1:9999")) {
            System.out.println(s);
        }
    }
}


import java.util.List;

/**
 * @className: TXGeneration
 * @Description: 未使用到，用来标记不同年代
 *   事务年代
 * @Author: wangyifei
 * @Date: 2023/2/19 10:20
 */
public class TXGeneration {
    private long epoch ;
    List<Participant> participant ;
}

流程图

mermaid

bluedraam_pp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java模拟事务Demo
while(True): print('adorable')
12-29 547
Java操作Oracle事务，以转账为例。 转账之前 package translate.commit; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLExcep...
springBoot+jpa+jta+atomikos十分钟实现分布式事务,模拟多数据源
qq_33449307的博客
10-14 3070
基于jta+atomikos解决分布式事务 模拟多数据源 jta: Java Transactio API,即是java中对事务处理的api,api即是接口的意思. atomikos：Atomikos TransactionsEssentials 是一个为Java平台提供增值服务的并且开源类事务管理器,基于2PC协议.不明白XA 2PC 3PC TCC的同学可以花几分钟的时间去看一下. 1....
利用netty模拟分布式事务锁
qq_38412637的博客
12-28 867
1.分布式事务简介 a,所谓分布式事务，是指的涉及多个数据库操作的事务，小编在开发中曾遇到过很多分布式事务的场景，今天我自己模拟了一个解决分布式事务的demo，希望和大家交流，并指出优缺点 b,下面简单画一个图说明一下分布式事务的小例子 c,图中简单描述了一个下订单的场景，用户下单首先会调用订单系统中下单，同时减库存，可能还有其他许多操作，如果下单顺利则不议论，如果下单失败，那么库存也应该失败 ...
分布式事务(3)
yao_wen_yu的博客
06-09 366
文章目录1.3 Hmily 实现 TCC 事务1.3.1 业务说明1.3.2 程序组成部分1.3.3 创建数据库 1.3 Hmily 实现 TCC 事务 1.3.1 业务说明 本实例通过Hmily实现TCC分布式事务，模拟两个账户的转账交易过程。 两个账户分别在不同的银行(张三在bank1、李四在bank2)，bank1、bank2是两个微服务。 交易过程是，张三给李四转账指定金额。 上述交易步骤，要么一起成功，要么一起失败，必须是一个整体性的事务。 1.3.2 程序组成部分 数据库：MySQL-5.7.
springcloud3 无分布式事务造成数据不一致场景模拟1
健康平安的活着的专栏
09-18 185
1.跨数据源的分布式事务。2.跨服务的分布式事务。
分布式事务
clear_0217的博客
11-13 398
协调者挂了，会通过选举出一个新的协调者如果处于第二阶段，假设参与者都没有挂，新的协调者会向所有的参与者来确认他们自身的情况来判断下一步的操作，但是假说说个别参与者挂了，比如协调者发送回滚命令，此时第一个参与者收到了并执行了，但是该参与者和协调者挂掉了，此时其他的参与者都没有收到命令，选举出来新的协调者询问其他参与者都OK，但是他不知道这个挂了的参与者到底什么情况，如果第二阶段发送的是提交的请求，不断重试，因为有一些参与者的事务已经提交成功，所以进行不断重试，直到所有事务提交成功，直到最后，进行人工介入。
多线程模拟分布式事务，2PC事务提交
还是从前那个少年
09-26 460
问题： 多线程破坏了方法事务的原子性。Spring 是使用ThreadLocal来存储Connection的，不同的线程Connection肯定不一样。所以我们加载Service 方法上的 @Transactional 是不起作用的。 思路： 每一个线程的事务是原子性的，所有的线程事务都提交了，这个操作的事务才是完成了。 代码： 明确子线程是执行业务的线程，主线程是控制事务的线程。 package com.xcr.thread.entity; import lombok.Data; impor
分布式事务视频教程
10-26
### 分布式事务基础知识与实践 #### 一、分布式事务概念及重要性 在现代软件架构中，随着业务复杂度的提升以及系统规模的扩大，单一应用已经很难满足实际需求，分布式系统应运而生。分布式系统由多个独立运行的...
spring整合atomikos实现分布式事务的方法示例
08-26
在实际应用中，你可以创建一个模拟的业务场景来测试分布式事务的效果。例如，可以在两个不同的数据库（如 MySQL 和 Oracle）上执行写操作，然后故意在操作之间引发异常，观察事务是否能够正确地进行回滚，从而验证 ...
spring+jotm+ibatis+mysql实现JTA分布式事务
08-15
在IT行业中，分布式事务处理是复杂系统架构中的一个重要环节，特别是在多数据库或服务协同工作的场景下。本项目“spring+jotm+ibatis+mysql实现JTA分布式事务”旨在利用这些技术来确保在分布式环境中的数据一致性。...
分布式事务框架LCN下载
04-16
分布式事务是现代企业级应用中不可或缺的技术之一，它允许在多台服务器或多个数据库之间保持数据的一致性。LCN（Little Cat Network）是一个专为Java设计的轻量级分布式事务解决方案，尤其适用于微服务架构。这个...
【分布式事务与分库分表】
最新发布
Java程序员廖志伟
04-07 184
🌟我是廖志伟，一名Java开发工程师、Java领域优质创作者、CSDN博客专家、51CTO专家博主、阿里云专家博主、清华大学出版社签约作者、产品软文专业写手、技术文章评审老师、问卷调查设计师、个人社区创始人、开源项目贡献者。🌎跑过十五公里、🚀徒步爬过衡山、🔥有过三个月减肥20斤的经历、是个喜欢躺平的狠人。
分布式事务模型-TCC
weixin_30498921的博客
12-27 616
一个TCC事务框架需要解决的当然是分布式事务的管理。关于TCC事务机制的介绍，可以参考TCC事务机制简介。 TCC事务模型虽然说起来简单，然而要基于TCC实现一个通用的分布式事务框架，却比它看上去要复杂的多，不只是简单的调用一下Confirm/Cancel业务就可以了的。 本文将以Spring容器为例，试图分析一下，实现一个通用的TCC分布式事务框架需要注...
至今指标总结
bluedraam_pp的博客
07-03 2788
*至今指标累加是什么 全量如何计算 整理如何计算 增量和全量计算的优缺点分析
zookeeper 的 Watch 功能三种应用场景
bluedraam_pp的博客
11-10 1105
zookeeper wacth 管理节点的高可用 分布式系统中的配置热部署 分布式锁
Flink 的算子介绍(上)
bluedraam_pp的博客
02-24 1034
Flink 算子用法总结
拉链表应用——财务总账
bluedraam_pp的博客
07-08 757
需求
Flink_窗口的底层实现逻辑
bluedraam_pp的博客
11-22 716
目的 写这篇文目的是为了加深对窗口和 watermark 的理解。 先感谢这位博主的辛勤劳动。我做的分析就是基于这位大侠做的。 下面上正题。 正题 窗口总体流程 窗口是用来切割无线流的，它把无线流切分成有限个碎片，通过计算碎片来计算流的某些性质。就像积分计算求球的体积。它将从球新到表面扇柱体是一个正方体，然后使用极限的思路，然后就计算出球体的体积。 根据不同的需求，我们有下面几种窗口类型。 数据流是无限的，我们可以统计每 n 个单位时间内的一些统计值。这就是 Tumbling 窗口。 我们也可以每隔 3
数据中台的一些问题整理
bluedraam_pp的博客
06-30 651
需求调研阶段 如何保证需要不漏、理解正确，减少不返工？ 如何描述清楚源数据中表的关联关系，使用什么工具和承载这个功能？ 设计阶段 如何设计维表 元数据解决了什么问题，如果没有思路，可以问一下详细的问题 数据一致性的问题，包括指标口径不一致、测试问题 数据复用 提高取数效率 降低学习成本 统一管理元数据，避免团队数据孤岛 保证数据质量，准（准时、准确）全（oneData），效果是数据用户敢用、放心用、用的有价值。 如果要做一个数据中台的项目，我们应该如何设计组织架构。 调度平台的核心功能：定时调度
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值