SpringBoot多线程Transactional抛出异常会回滚吗？

最新推荐文章于 2024-08-26 10:32:22 发布

大明湖畔的壮汉

最新推荐文章于 2024-08-26 10:32:22 发布

阅读量1.5k

点赞数 25

本文链接：https://blog.csdn.net/qq_34193918/article/details/134360078

版权

@Transactional

@Transactional 是一个常用的 Java 注解，通常在框架中使用，如 Spring，用于对方法或类实现事务管理。当一个方法或类被 @Transactional 注解标记时，表示其中的代码应该在一个事务中执行。
事务是一个逻辑工作单元，它包含一个或多个数据库操作。通过应用 @Transactional 注解，确保在方法内部的所有数据库操作要么全部成功，要么如果有任何一个失败，则所有操作都会被回滚，使得数据库恢复到原始状态。
以下是 @Transactional 的工作原理：

1.如果一个方法被标记为 @Transactional，则在方法执行之前会启动一个事务。
2.如果方法成功执行（即没有抛出运行时异常），事务将被提交，对数据库的任何更改都会被保存。
3.如果在方法执行期间发生异常，事务将被回滚，并且在该事务中对数据库所做的任何更改都将被丢弃。
4.如果被注解的方法调用其他同样被 @Transactional 注解标记的方法，同一个事务会传播到嵌套的方法调用中。换句话说，所有方法将共享同一个事务。
5.@Transactional 注解可以应用于方法级别或类级别。当应用于类级别时，该类的所有公共方法都会自动在事务中执行。
6.还可以指定其他属性来自定义事务的行为，例如隔离级别、传播行为、只读模式和超时时间。

总的来说，@Transactional 是一个强大的工具，用于在 Java 应用程序中管理事务行为。它有助于确保数据的一致性，并使开发人员能够处理复杂的数据库操作，而无需担心手动事务管理。

多线程异常处理

现在思考一个小问题，假如A是一个线程，a1、a2…是A的子线程，那么a1抛出异常的时候，A能捕捉到异常吗？

答案是不完全能:

线程设计的理念：“线程的问题应该线程自己本身来解决，而不要委托到外部。”，正常情况下，如果不做特殊的处理，在主线程中是不能够捕获到子线程中的异常的。但是还是可以通过注册uncaughtException捕获子线程中的异常（仅限RuntimeException）。

            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    save(new PsycheInfo());
                    log.warn(Thread.currentThread().getName() + "insert success");
                }
            });
            t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                @Override
                public void uncaughtException(Thread t, Throwable e) {
                    e.printStackTrace();
                }
            });

Spring实现事务的原理是通过ThreadLocal把数据库连接绑定到当前线程中，同一个事务中数据库操作使用同一个jdbc connection，新开启的线程获取不到当前jdbc connection。那么新创建的线程中的事务如何把任务添加到主线程的事务中去呢？

spirng的事务传播机制

REQUIRED（默认）:
如果当前没有事务，就新建一个事务。如果已经存在一个事务中，加入到这个事务中。
SUPPORTS:
如果当前存在事务，就加入这个事务；如果当前没有事务，就以非事务方式执行。
MANDATORY:
该方法必须在一个事务中运行，如果当前没有事务，则抛出异常。
REQUIRES_NEW:
创建一个新事务，如果当前存在事务，将其挂起。
NOT_SUPPORTED:
以非事务方式执行操作，如果当前存在事务，将其挂起。
NEVER:
以非事务方式执行，如果当前存在事务，则抛出异常。

使用方式类似于：

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void transactionalMethod() {
    // Your business logic
}

合理的使用事务传播，就可以把新创建的事务加入到已有的事务中。

Spring事务的原理

一句话：Spring实现事务的原理是通过ThreadLocal把数据库连接绑定到当前线程中，同一个事务中数据库操作使用同一个jdbc connection，新开启的线程获取不到当前jdbc connection。

也就是说，我没法可以在新建的线程里获取到主线程使用的同一个Connection，如果我们能通过Connection关闭线程自动提交改成手动提交，我们就可以自己控制什么时候回滚事务。

我的实现方法（抛砖引玉）

    @Autowired
    private DataSource dataSource;
    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void testAsync() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        CountDownLatch mainDownLatch = new CountDownLatch(1);
        AtomicBoolean atomicBoolean = new AtomicBoolean(false);
        Thread.UncaughtExceptionHandler uncaughtExceptionHandler = (t, e) -> {
            atomicBoolean.set(false);
            System.out.println(t.getName());
            e.printStackTrace();
        };
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(() -> {
                try {
                    Connection connection = dataSource.getConnection();
                    connection.setAutoCommit(false);
                    save(new PsycheInfo());
                    countDownLatch.countDown();
                    if (countDownLatch.getCount() == 2) {
                        throw new RuntimeException("test exception");
                    }
                    log.warn(Thread.currentThread().getName() + "insert success");
                    mainDownLatch.await();
                    if (!atomicBoolean.get()) {
                        connection.rollback();
                    }
                } catch (SQLException sqlException) {
                    throw new RuntimeException(sqlException.getMessage());
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    countDownLatch.countDown();
                }
            });
            t.setUncaughtExceptionHandler(uncaughtExceptionHandler);
            threadPoolTaskExecutor.submit(t);
        }
        countDownLatch.await();
        if (atomicBoolean.get()) {
            mainDownLatch.countDown();
        }else {
            System.out.println("test exception");
            mainDownLatch.countDown();
            throw new InterruptedException("test exception");
        }
    }