@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");
}
}
在这个实现方法中，我们需要设置两个CountDownLatch，countDownLatch是用来记录线程执行的状态，等十个线程执行完毕由主线程判断是否有必要回滚，atomicBoolean就是回滚的标志。子线程等待主线程的mainDownLatch，判断是否回滚。
推荐阅读
发表评论