多线程事务怎么回滚

CyclicBarrier

加入数据库连接够用的前提下:

   @Autowired
   private PlatformTransactionManager platformTransactionManager;
   @Autowired
   private TransactionDefinition transactionDefinition;

   private void thread1(AtomicBoolean rollback, CyclicBarrier cb) {
        TransactionTemplate transactionTemplate = new TransactionTemplate(platformTransactionManager);
        transactionTemplate.execute(new TransactionCallback<Void>() {
            @Override
            public Void doInTransaction(TransactionStatus transactionStatus) {
                try {
                    contentService.updateById(new Content().setId(2L).setSort(1));
                } catch (Exception e) {
                    rollback.set(true);
                }
                try {
                    cb.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                if (rollback.get()) {
                    transactionStatus.setRollbackOnly();
                }
                return null;
            }
        });
    }

    private void thread2(AtomicBoolean rollback, CyclicBarrier cb) {
        TransactionStatus transaction = platformTransactionManager.getTransaction(transactionDefinition);
        try {
            contentService.updateById(new Content().setId(1L).setSort(1));
        } catch (Exception e) {
            rollback.set(true);
        }
        try {
            cb.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        if (rollback.get()) {
            platformTransactionManager.rollback(transaction);
            return;
        }
        platformTransactionManager.commit(transaction);
    }

    @Override
    @Transactional
    public void test(String s) throws SQLException {
        AtomicBoolean rollback = new AtomicBoolean(false);
        CyclicBarrier cb = new CyclicBarrier(3);
        new Thread(new Runnable() {
            @Override
            public void run() {
                thread1(rollback, cb);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                thread2(rollback, cb);
            }
        }).start();
        try {
            cb.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        if (rollback.get()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

缺点:一个线程一个事务,一个连接,可能把连接池耗空。
多个线程对应多个事务,如果操作同一张表有可能死锁。
可考虑分布式事务。

CountDownLatch 可以由CyclicBarrier改造

mybatis 版

@Resource
private SqlSessionTemplate sqlSessionTemplate;
public void test(String s) throws SQLException {
        SqlSessionFactory sqlSessionFactory = sqlSessionTemplate.getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Connection connection = sqlSession.getConnection();
        connection.setAutoCommit(false);
        ContentDao mapper = sqlSession.getMapper(ContentDao.class);
        Content c = new Content().setTime(LocalDateTime.now()).setUrl("test3").setPic("pic3").setCategoryId(0).setSort(0);
        mapper.insert(c);
        AtomicBoolean rollFlag = new AtomicBoolean(false);
        CompletableFuture<Void> job1 = CompletableFuture.runAsync(() -> {
            Content content = mapper.selectById(1);
            content.setSort(10);
            mapper.updateById(content);
        }).exceptionally(e -> {
            e.printStackTrace();
            rollFlag.set(true);
            return null;
        });
        CompletableFuture<Void> job2 = CompletableFuture.runAsync(() -> {
            Content content = mapper.selectById(2);
            content.setSort(10);
            mapper.updateById(content);
            int a = 1 / 0;
        }).exceptionally(e -> {
            e.printStackTrace();
            rollFlag.set(true);
            return null;
        });
        try {
            CompletableFuture.allOf(job1, job2).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
            rollFlag.set(true);
        } finally {
            if (rollFlag.get()) {
                connection.rollback();
            } else {
                connection.commit();
            }
            connection.close();
        }
}

jpa 版

    Connection connection = session.doReturningWork(new AbstractReturningWork<Connection>() {
        @Override
        public Connection execute(Connection connection) throws SQLException {
            connection.setAutoCommit(false);
            return connection; //获取原生jdbc操作
        }
    });
    public void test2(Integer a) throws SQLException {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        Session session = entityManager.unwrap(Session.class);
        AtomicBoolean rollFlag = new AtomicBoolean(false);
        Transaction transaction = session.beginTransaction();
        CompletableFuture<Void> job1 = CompletableFuture.runAsync(() -> {
            Customer customer = session.get(Customer.class, 1L);
            customer.setAge(10);
            session.save(customer);
        }).exceptionally(e -> {
            e.printStackTrace();
            rollFlag.set(true);
            return null;
        });
        try {
            CompletableFuture.allOf(job1).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
            rollFlag.set(true);
        } finally {
            if (rollFlag.get()) {
                transaction.rollback();
            } else {
                transaction.commit();
            }
        }
    }
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 对于这个问题,我可以回答。在 Spring Boot 中,多线程事务回滚可以通过使用 @Transactional 注解来实现。在多线程环境下,需要使用 TransactionTemplate 来控制事务的边界。如果一个线程抛出异常,所有参与到这个事务中的线程都会回滚。 ### 回答2: 在Spring Boot中,我们可以使用多线程执行一些并发操作,并在其中进行事务管理。但是,默认情况下,多线程事务是无法进行回滚的。 要实现多线程事务回滚,我们可以采用以下两种方式: 1. 基于编程式事务管理: 在方法中使用编程式事务管理器,并手动在异常发生时进行事务回滚。首先,我们需要在方法上加上`@Transactional`注解来启用事务管理。然后,在方法体中,我们可以通过获取当前事务管理器的实例,并通过它来进行事务管理。当出现异常时,我们可以使用`TransactionAspectSupport.currentTransactionStatus().setRollbackOnly()`方法来进行事务回滚。这样,当任何一个线程中的事务发生异常时,整个事务都会回滚。 2. 基于注解式事务管理: 在方法上加上`@Async`注解,并结合`@Transactional`注解来启用异步事务管理。首先,我们需要在`@Configuration`类中使用`@EnableAsync`注解启用异步支持。然后,在方法上加上`@Async`注解来开启异步执行。接着,我们需要在方法上同时添加`@Transactional`注解来启用事务管理。这样,当方法执行时,Spring会将其放入一个独立的线程中并异步执行,同时也会在子线程中开启一个新的事务。当发生异常时,整个子线程中的事务都会进行回滚。 总结起来,实现Spring Boot多线程事务回滚可以通过编程式事务管理和注解式事务管理两种方式来实现。无论使用哪种方式,我们都需要确保在事务异常发生时进行事务回滚,以保证数据的一致性和完整性。 ### 回答3: 在Spring Boot中,多线程事务回滚可以通过使用@Transactional注解来实现。事务是由Spring事务管理器管理的,它可以管理多个线程同时进行的数据库操作。 通过在方法上添加@Transactional注解,可以将该方法纳入到一个事务中。当事务中的任何一个操作失败时,整个事务都会被回滚,即所有之前的操作都会撤销。 在多线程环境下,如果多个线程同时操作同一个数据库表,通过@Transactional注解可以确保他们在同一个事务中进行操作。当其中一个线程操作失败时,整个事务将会被回滚,所有线程的操作都会被撤销。 为了实现多线程事务回滚,需要确保所有的数据库操作都在同一个事务中执行。这可以通过在多线程方法的外部添加@Transactional注解来实现。当方法被调用时,将会启动一个新的事务,并将所有线程的操作添加到这个事务中。 需要注意的是,在使用多线程事务时,事务的隔离级别也非常重要。可以根据具体需求来选择适当的隔离级别。在默认情况下,Spring Boot使用的是数据库的默认隔离级别。 总之,使用Spring Boot的@Transactional注解可以很方便地实现多线程事务回滚。通过将所有操作添加到同一个事务中,可以在任何一个操作失败时回滚整个事务。而在多线程环境下,则需要保证所有线程的操作都在同一个事务中执行,以确保事务的一致性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值