分布式事务框架底层原理(2PC)

最新推荐文章于 2023-06-12 17:49:53 发布
最新推荐文章于 2023-06-12 17:49:53 发布
阅读量222 收藏 1
点赞数
分类专栏： java 文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xianmingsu/article/details/112850848
版权

事务中的全部操作，要求要么都成功，要么都不成功。通常在同一个jvm中是比较容易做到的，例如数据库JDBC操作，Spring能够帮我们做这件事。但是在分布式环境下，A服务调用B服务,在这个过程出现了异常，又该怎么保证A、B服务的事务都回滚呢？

分布式事务一般有三种解决方案：
1、2PC
2、最终消息一致性
3、TCC

这里我们介绍2PC这种解决方案。
在这里插入图片描述
在A调用B的过程中，A出现了一个异常。

A服务：

@Service
public class DemoService {

    @Autowired
    private DemoDao demoDao;
    
    @SxmTransactional(start = true)
    public void test() {
        demoDao.insert("server1");
        HttpUtil.post("http://localhost:8082/server2/test");
        int i = 1/0;
    }
}

B服务：

@Service
public class DemoService {

    @Autowired
    private DemoDao demoDao;

    @SxmTransactional(end = true)
    public void test() {
        System.out.println("执行server2业务");
        demoDao.insert("server2");
    }
}

自定义分布式事务注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Transactional
public @interface SxmTransactional {
    boolean start() default false;
    boolean end() default false;
}

我们需要在A服务执行方法之前，提前做些准备，这里借助spring的AOP来完成。

//保证当前切面先ConnectionAspect执行，值越小有越高的优先级
@Order(10000)
@Aspect
@Component
public class TransactionAspect {
    @Around("@annotation(com.su.annotation.SxmTransactional)")
    public void invoke(ProceedingJoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        SxmTransactional annotation = method.getAnnotation(SxmTransactional.class);
        String gid = "";
        if (annotation.start()){
            //创建事务组
            gid = TransactionManager.createGroup();
        }else {
            //从上一个服务调用传过来
            gid = TransactionManager.getCurrentGroup();
        }
        //创建本地事务
        Transaction transaction = TransactionManager.createTransaction(gid);
        try {
            //执行目标方法(在这里我们要拿到真正数据库操作连接的控制权)
            //注意：这里要保证目标方法快速执行完，不能形成等待死锁，所以在目标方法中新建一个线程来执行commit或rollback
            joinPoint.proceed();
            //向netty服务端事务管理器提交本地事务 commit
            TransactionManager.commitTransaction(transaction,annotation.end(),TransactionType.COMMIT);
        } catch (Throwable throwable) {
            //向netty服务端事务管理器提交本地事务 rollback
            TransactionManager.commitTransaction(transaction,annotation.end(),TransactionType.ROLLBACK);
            throwable.printStackTrace();
        }
    }
}

在执行目标方法时，涉及到了jdbc操作，所以我们要拿到数据库操作连接的控制权，这里同样使用AOP来完成。

@Aspect
@Component
public class ConnectionAspect {
    @Around("execution(* javax.sql.DataSource.getConnection(..))")
    public Connection getConnection(ProceedingJoinPoint joinPoint){
        try {
            //真正的jdbc连接对象
            Connection connection = (Connection) joinPoint.proceed();
            //从ThreadLocal中获取本地当前Transaction对象,所以要让TransactionAspect先执行
            Transaction currentTransaction = TransactionManager.getCurrentTransaction();
            return new SxmConnection(connection,currentTransaction);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return null;
    }
}

返回包装后的连接对象：

public class SxmConnection implements Connection {

    //真正的数据库连接对象
    private Connection connection;

    //当前连接的本地自定义事务对象
    private Transaction transaction;

    public SxmConnection(Connection connection,Transaction transaction) {
        this.connection = connection;
        this.transaction = transaction;
    }

    @Override
    public void commit() throws SQLException {
        new Thread(()->{
            //需要等待netty服务端事务管理器通知，然后才提交
            transaction.await();
            //netty服务端可能会更改transaction的TransactionType
            try {
                if (transaction.getType().equals(TransactionType.COMMIT)){
                    connection.commit();
                }else {
                    connection.rollback();
                }
                connection.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }).start();
    }

    @Override
    public void rollback() throws SQLException {
        new Thread(()->{
            //需要等待netty服务事务管理器通知，然后才回滚
            transaction.await();
            try {
                connection.rollback();
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }).start();
    }

    //注意这里不能调用connection.close(),如果真正的连接对象都关闭了，后面都不用玩了。
    @Override
    public void close() throws SQLException {
    }

    @Override
    public Statement createStatement() throws SQLException {
        return connection.createStatement();
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        return connection.prepareStatement(sql);
    }
    //以下还有许多Override方法
    ......
}

本地事务管理器：

@Component("localTransactionManager")
public class TransactionManager {

    //用于保存本地事务管理器管理的所有事务组，key为groupId
    public static Map<String,Map<String,Transaction>> groupMap = new HashMap();

    //用于保存本地事务组groupId
    public static ThreadLocal<String> groupThreadLocal = new ThreadLocal<>();

    //用于保存本地事务
    public static ThreadLocal<Transaction> transactionThreadLocal  =new ThreadLocal<>();

    //用于记录当前事务标号
    public static ThreadLocal<Integer> currentTransactionNum = new ThreadLocal<>();

    public static NettyClient client;

    @Autowired
    public void setNettyClient(NettyClient nettyClient){
        client = nettyClient;
    }

    /**
     * 创建事务组
     */
    public static String createGroup(){
        String gid = UUID.randomUUID().toString();
        groupMap.put(gid,new HashMap<>());
        groupThreadLocal.set(gid);
        //发送创建事务组消息给netty服务器
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("groupId",gid);
        jsonObject.put("command","create");
        client.send(jsonObject);
        return gid;
    }
    /**
     * 创建本地事务
     * @param gid
     */
    public static Transaction createTransaction(String gid){
        Transaction transaction = new Transaction();
        String tid = UUID.randomUUID().toString();
        transaction.setId(tid);
        transaction.setGid(gid);
        if (groupMap.get(gid)==null){
            groupMap.put(gid,new HashMap<>());
        }
        //保存到本地事务管理器
        transactionThreadLocal.set(transaction);
        groupMap.get(gid).put(tid,transaction);
        //保存本地事务标号
        saveCurrentTransactionNum();
        return transaction;
    }

    /**
     * 保存本地事务标号
     * 上一个服务的基础上加1
     */
    private static void saveCurrentTransactionNum() {
        Integer num = currentTransactionNum.get()==null?0:currentTransactionNum.get()+1;
        currentTransactionNum.set(num);
    }

    /**
     * 得到本地事务标号
     */
    public static Integer getCurrentTransactionNum(){
        return currentTransactionNum.get();
    }

    /**
     * 设置本地事务标号
     */
    public static void setCurrentTransactionNum(Integer num){
        currentTransactionNum.set(num);
    }

    /**
     * 设置当前线程维护的事务组
     * @param gid
     */
    public static void setCurrentGroup(String gid){
        groupThreadLocal.set(gid);
    }

    /**
     * 得到当前线程维护的事务组
     * @return
     */
    public static String getCurrentGroup(){
        return groupThreadLocal.get();
    }


    /**
     * 得到当前线程维护的事务
     */
    public static Transaction getCurrentTransaction(){
        return transactionThreadLocal.get();
    }


    /**
     * 向netty服务器提交事务
     */
    public static void commitTransaction(Transaction transaction,boolean end,TransactionType type){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("groupId",transaction.getGid());
        jsonObject.put("transactionId",transaction.getId());
        jsonObject.put("command","add");
        jsonObject.put("end",end);
        jsonObject.put("transactionType",type);
        jsonObject.put("transactionNum",getCurrentTransactionNum());
        client.send(jsonObject);
    }
}

本地事务：

public class Transaction {
    //事务id
    private String id;
    //事务组id
    private String gid;
    //事务类型(commit or rollback)
    private TransactionType type;
    //当前事务对应的锁对象
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getGid() {
        return gid;
    }

    public void setGid(String gid) {
        this.gid = gid;
    }

    public TransactionType getType() {
        return type;
    }

    public void setType(TransactionType type) {
        this.type = type;
    }

    public Condition getCondition() {
        return condition;
    }

    //等待(当前线程会等待在这个condition对象的等待队列中)
    public void await(){
        try {
            lock.lock();
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //唤醒
    public void signal(){
        try {
            lock.lock();
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
}

事务类型：

public enum TransactionType {
    COMMIT,ROLLBACK
}

本地netty客户端：

@Component
public class NettyClient implements InitializingBean {

    public NettyClientHandler client = null;

    private static ExecutorService executorService = Executors.newCachedThreadPool();

    @Override
    public void afterPropertiesSet() throws Exception {
        start("localhost", 8080);
    }

    public void start(String hostName, Integer port) {
        client = new NettyClientHandler();

        Bootstrap b = new Bootstrap();
        EventLoopGroup group = new NioEventLoopGroup();
        b.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        pipeline.addLast("decoder", new StringDecoder());
                        pipeline.addLast("encoder", new StringEncoder());
                        pipeline.addLast("handler", client);
                    }
                });

        try {
            b.connect(hostName, port).sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void send(JSONObject jsonObject) {
        try {
            client.call(jsonObject);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    private ChannelHandlerContext context;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        context = ctx;
    }

    /**
     * 接收服务端通知
     */
    @Override
    public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        JSONObject jo = JSON.parseObject((String) msg);
        String groupId = jo.getString("groupId");
        String noticeCommand = jo.getString("noticeCommand");
        String transactionId = jo.getString("transactionId");
        System.out.println("client receive command:"+noticeCommand);
        Transaction transaction = TransactionManager.groupMap.get(groupId).get(transactionId);
        if ("commit".equals(noticeCommand)) {
            transaction.setType(TransactionType.COMMIT);
        }else {
            transaction.setType(TransactionType.ROLLBACK);
        }
        transaction.signal();
    }

    public synchronized Object call(JSONObject data) throws Exception {
        context.writeAndFlush(data.toJSONString()).channel().newPromise();
        return null;
    }
}

HttpUtil：

@Component
public class HttpUtil {

    private static RestTemplate restTemplate = new RestTemplate();

    public  static Object post(String url){
        HttpHeaders header = new HttpHeaders();
        header.set("groupId", TransactionManager.getCurrentGroup());
        header.set("transactionNum",String.valueOf(TransactionManager.getCurrentTransactionNum()));
        HttpEntity<MultiValueMap<String, String>> httpEntity = new HttpEntity<>(null, header);
        return  restTemplate.postForObject(url,httpEntity,Object.class);
    }
}

请求拦截器：

@Configuration
public class WebAppConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new RequestInterceptor());
    }
}

public class RequestInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //接收从上一个服务调用传过来的
        String groupId = request.getHeader("groupId");
        String transactionNum = request.getHeader("transactionNum");
        TransactionManager.setCurrentGroup(groupId);
        TransactionManager.setCurrentTransactionNum(Integer.valueOf(transactionNum==null? "0":transactionNum));
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

服务端事务管理器：

/**
 * 作为分布式事务管理器，它需要：
 * 1. 创建并保存事务组
 * 2. 保存各个子事务在对应的事务组内
 * 3. 统计并判断事务组内的各个子事务状态，以算出当前事务组的状态（提交or回滚）
 * 4. 通知各个子事务提交或回滚
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    //private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    //保存事务组对应的所有channel
    private static Map<String,Map<String,Channel>> channelGroupMap = new ConcurrentHashMap<>();
    //保存事务组内所有的事务
    private static Map<String,List<JSONObject>> groupTransactions = new ConcurrentHashMap<>();
    //保存事务组内所有事务的状态
    private static Map<String,List<String>> groupStatus = new ConcurrentHashMap<>();
    //保存每个事务组结束状态
    private static Map<String,Boolean> endGroupMap = new ConcurrentHashMap<>();
    //保存每个事务组应该有的事务数量
    private static Map<String,Integer> countTransGroupMap = new ConcurrentHashMap<>();

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("接受数据:" + msg.toString());
        JSONObject jsonObject = JSON.parseObject((String) msg);
        String groupId = jsonObject.getString("groupId");
        String command = jsonObject.getString("command");
        System.out.println("groupId:"+groupId);
        System.out.println("command:"+command);
        if ("create".equals(command)){
            createGroup(groupId);
        }else if ("add".equals(command)){
            boolean end = jsonObject.getBoolean("end");
            String transactionId = jsonObject.getString("transactionId");
            String transactionType = jsonObject.getString("transactionType");
            Integer transactionNum = jsonObject.getInteger("transactionNum");
            //保存事务组对应的channel
            addChannelMap(groupId,transactionId,ctx.channel());
            //保存事务组中的事务
            addGroupTransactions(groupId,jsonObject);
            addGroupStatus(groupId,transactionType);
            if (end){
                System.out.println("------已经执行-----");
                endGroupMap.put(groupId,Boolean.TRUE);
                countTransGroupMap.put(groupId,transactionNum);
            }
            //如果当前事务组收到end,并且事务组应有事务数量等于实际接收到事务数量，触发计算事务组状态
            if (endGroupMap.get(groupId) && countTransGroupMap.get(groupId)==groupTransactions.get(groupId).size()){
                //算出当前事务组的状态（提交or回滚）
                String noticeCommand = "";
                List<JSONObject> result = new LinkedList<>();
                if (groupStatus.get(groupId).contains("ROLLBACK")){
                    noticeCommand = "rollback";
                }else {
                    noticeCommand = "commit";
                }
                sendResult(groupId,noticeCommand);
            }
        }
    }

    private void createGroup(String groupId) {
        groupTransactions.put(groupId,new LinkedList<>());
        groupStatus.put(groupId,new LinkedList<>());
    }

    private void addGroupTransactions(String groupId, JSONObject jsonObject) {
        if (groupTransactions.get(groupId)==null){
            groupTransactions.put(groupId,new LinkedList<>());
        }
        groupTransactions.get(groupId).add(jsonObject);
    }

    private void addGroupStatus(String groupId, String transactionType) {
        if (groupStatus.get(groupId)==null){
            groupStatus.put(groupId,new LinkedList<>());
        }
        groupStatus.get(groupId).add(transactionType);
    }

    private void addChannelMap(String groupId,String transactionId, Channel channel) {
        if (channelGroupMap.get(groupId)==null){
            channelGroupMap.put(groupId,new HashMap<>());
        }
        channelGroupMap.get(groupId).put(transactionId,channel);
    }

    /**
     * 通知本地事务
     * 这里就不考虑发送失败等情况了
     */
    private void sendResult(String groupId, String noticeCommand) {
        Map<String, Channel> channels = channelGroupMap.get(groupId);
        for (Map.Entry<String, Channel> entry : channels.entrySet()) {
            JSONObject jo = new JSONObject();
            jo.put("groupId",groupId);
            jo.put("noticeCommand",noticeCommand);
            jo.put("transactionId",entry.getKey());
            ChannelFuture channelFuture = entry.getValue().writeAndFlush(jo.toJSONString());
            System.out.println(channelFuture);
        }
        //释放资源
        channelGroupMap.remove(groupId);
        groupTransactions.remove(groupId);
        groupStatus.remove(groupId);
        endGroupMap.remove(groupId);
        countTransGroupMap.remove(groupId);
    }
}

至此，分布式事务框架已完成，A、B服务出现异常，数据库都会回滚。但是不能用于生产环境，还有许多需要优化的地方，这里是为了描述工作原理。

Sxm&
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事务理解和配置
Student108的博客
09-07 2391
文章目录1 Spring事务1.1 事务简介1.1.1 什么是事务1.1.2 事物的特性1.1.3 不考虑事物会引发的安全问题1.1.4 事务隔离级别1.2 事务的传播行为1.3 编程式事务(需要手动写代码,了解)1.3.1 配置平台事务管理器1.3.2 Spring提供了事务管理的模板类1.3.3 在业务层注入事务管理的模板1.3.4 编写事务管理的代码1.4 声明式事务(xml配置)1.4.1 配置事务管理器1.4.2 配置增强1.4.3 AOP的配置1.5 声明式事务(注解)1.5.1 配置事务管理器
LCN分布式事务框架原理详解4.0
02-24
1、地址：2、4.0添加升级如下功能：（1）3.0虽然有事务补偿机制，但4.0在此基础上不仅添加事务补偿机制的策性，还添加了管理的后台可以看到补偿的数据；同时也添加了一个回调地址，可以在补偿之前可以最先知道这次...
Transaction rolled back because it has been marked as rollback-only
走马观花
10-20 6216
http://hsyd.iteye.com/blog/586772 错误信息： Transaction rolled back because it has been marked as rollback-only  原因：事务提交多次 检查代码 例：service嵌套service =======================================================
Springboot注解@Transactional(propagation = Propagation.REQUIRED)
justlpf的专栏
06-12 1189
【代码】Springboot注解@Transactional(propagation = Propagation.REQUIRED)
@Transactional事务回滚异常：Transaction rolled back because it has been marked as rollback-only
程序员Forlan的博客
01-08 6108
本文主要探讨了一个常见的Spring框架中的事务管理问题，即事务回滚异常@Transactional。首先，通过问题描述，让读者了解这个问题的现象和影响。然后，通过原因分析，深入解析了导致这个问题的几种可能原因，包括异常示例代码和查看源码。最后，通过解决方案部分，给出了解决这个问题的几种方法，并推荐了最佳实践。通过本文，读者可以更好地理解Spring框架中的事务管理机制，并学会如何解决常见的事务回滚异常问题。
@Transactional嵌套事务失效异常Transaction rolled back because it has been marked as rollback-only
竹林幽深
07-19 4007
Transactional嵌套事务失效异常Transaction rolled back because it has been marked as rollback-only
分布式计算框架Hadoop原理及架构全解
02-25
本文来自于csdn，这篇文章讲解了分布式计算框架的核心内容、架构图详解，运用流程等Hadoop是Apache软件基金会所开发的并行计算框架与分布式文件系统。最核心的模块包括HadoopCommon、HDFS与MapReduce。HDFSHDFS是...
分布式事务的实现原理
02-24
在SOA与微服务架构大行其道的今天，在分布式的多个服务中保证业务的一致性就需要我们实现分布式事务。在文章的开头，我们已经说过事务是数据库管理系统执行过程中的一个逻辑单位，它能保证一组数据库操作要么全部...
分布式事务之2PC事务处理原理
01-08
实现的一个简单2PC分布式事务框架，客户端与服务端通信使用Netty，市面上成熟的2PC分布式事务框架有：LCN，大致的处理流程都是按照这种方式来的，希望对于学习分布式事务的小伙伴有所帮助。
【Java 基础】SpringBoot 中 @Transactional 注解的使用与实践
热门推荐
yuxiangdeming的博客
06-12 1万+
事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。本篇只说明声明式注解。 事务：是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。 事务的四大特性：只需在方法加上 @Transactional 注解就可以了。如下有一个保存数据的方法，加入 @transactiona
事物传播行为：propagation = Propagation.REQUIRES_NEW 不生效问题
fenjindecainiao1的博客
10-24 5696
@Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED, rollbackFor = {Throwable.class}, readOnly = false) 传播行为：propagation = Propagation.REQUIRES_NEW 不生效问题 因为： 由...
【MySQL】Deadlock found when trying to get lock； try restarting trans
qq_27579471的博客
05-17 1294
初始化数据： CREATE TABLE `t_test` ( `FID` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键', `FCREATE_TIME` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `FMODIFY_TIME` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_T
spring @Transactional注解参数详解
hsgao_water的博客
08-22 4716
事务注解方式 @Transactional 当标于类前时, 标示类中所有方法都进行事务处理 ： @Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT,rollbackFor=Exception.class) public class StudentServiceImpl extends
JAVA事务@Transactional之propagation
云之彼端
06-09 2662
1）REQUIRED 如果有事务则加入事务，如果没有事务，则创建一个新的（默认值） @Transactional(propagation=Propagation.REQUIRED) 2）NOT_SUPPORTED Spring不为当前方法开启事务，相当于没有事务 @Transactional(propagation=Propagation.NOT_SUPPORTED) 3）REQUIRES_NEW 不管是否存在事务，都创建一个新的事务，原来的方法挂起，新的方法执行完毕后，继续执行老的事务 @Transa
Commit cannot be completed since the group has already rebalanced and assign
墨痕诉清风的博客
06-08 1万+
如何理解 这里是说提交commit失败, 因为这个组已经重新分配了正常情况下, kafka会有一个配置用于设置一条消息的过期时间, 在规定时间内, 如果消费者提交了消费完成的信息, 那么就可以正常的分配下一条记录给消费者, 并且将当前记录的状态记为"已消费"状态, 对消息队列做一个标识, 避免重复消费kafka中配置的规定返回消息时间, 默认是300s, 也就是5分钟, 但是有一些业务逻辑处理起来比较复杂, 数据量又比较庞大, 那么5分钟是肯定处理不完的, 比如导入一个5G的文件, 然后逐条插入数据库,
MySQL死锁(Deadlock found when trying to get lock； try restarting transaction)
xhy1999的博客
11-19 6048
前言：最近一个SpringBoot项目在一段时间内出现了大量的死锁,花了些时间,最总解决了问题,在此记录一下。 写在前面：本次问题的核心是在事务检索和操作时没有使用索引,数据库使用了表锁,导致操作时间过长,从而使锁占用时间过长,最终导致死锁。 环境： 数据库：MySQL 5.7 存储引擎：InnoDB (1).定位问题 进入数据库命令行，执行以下指令，查看最近一次死锁的信息： show engine innodb status; MySQL默认只能看到最近一次的死锁,如果想要把死锁信息保存到MySQL
手动开启事物
19li
11-02 223
//手动开启事务 TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition); try { // 代码逻辑 dataSourceTransactionManager.commit(transactionStatus); } catch (Exception e) { // TODO: 2019-08-09 增加钉钉或者邮件提示 lo.
11.方法调用
aa348699531的博客
11-25 155
方法调用并不等同于方法执行，方法调用阶段唯一的任务就是确定被调用方法的版本，暂时还不涉及方法内部的具体运行过程。 解析 所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中的一部分符号引用转化为直接引用，这种解析能成立的前提是：方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。...
spring事务失效
weixin_30797199的博客
01-22 440
最近在做spring 项目中突然发现事务在遇到异常是没有回滚而是提交了，在查了大量的资料之后，算是有了一点头绪，写下来方便以后查找： 前些日子一朋友在需要在目标对象中进行自我调用，且需要实施相应的事务定义，且网上的一种通过BeanPostProcessor的解决方案是存在问题的。因此专门写此篇帖子分析why。 1、预备知识 aop概念请参考【http://www.iteye.com/topi...
java 分布式事务框架
最新发布
08-31
总结起来，Java分布式事务框架Hmily可以帮助开发人员处理分布式事务的一致性问题，提供了多种解决方案，包括2PC、TCC和最大努力通知等。在使用Hmily时，需要对数据库进行配置，并通过配置信息实现事务的管理和控制。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值