Python 官方文档:入门教程 => 点击学习
spring事务传播机制和数据库隔离级别 在标准sql规范中定义了4个事务隔离级别,不同隔离级别对事务处理不同 。 未授权读取(Read Uncommitted): 也称
在标准sql规范中定义了4个事务隔离级别,不同隔离级别对事务处理不同 。
隔离级别 | 更新丢失 | 脏读取 | 重复读取 | 幻读 |
---|---|---|---|---|
未授权读取 | N | Y | Y | Y |
授权读取 | N | N | Y | Y |
可重复读取 | N | N | N | Y |
串行 | N | N | N | N |
Spring在TransactionDefinition接口中规定了7种类型的事务传播行为,它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播:
package org.springframework.transaction.annotation;
import org.springframework.transaction.TransactionDefinition;
public enum Propagation {
REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
NEVER(TransactionDefinition.PROPAGATION_NEVER),
NESTED(TransactionDefinition.PROPAGATION_NESTED);
private final int value;
Propagation(int value) { this.value = value; }
public int value() { return this.value; }
}
package org.springframework.transaction;
import java.sql.Connection;
public interface TransactionDefinition {
int PROPAGATION_REQUIRED = 0;
int PROPAGATION_SUPPORTS = 1;
int PROPAGATION_MANDATORY = 2;
int PROPAGATION_REQUIRES_NEW = 3;
int PROPAGATION_NOT_SUPPORTED = 4;
int PROPAGATION_NEVER = 5;
int PROPAGATION_NESTED = 6;
int ISOLATION_DEFAULT = -1;
int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;
int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;
int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;
int TIMEOUT_DEFAULT = -1;
int getPropagationBehavior();
int getIsolationLevel();
int getTimeout();
boolean isReadOnly();
String getName();
}
启动一个新的, 不依赖于环境的 "内部" 事务.
这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行.
如果外部事务 commit, 嵌套事务也会被 commit;
如果外部事务 roll back, 嵌套事务也会被 roll back 。
开始一个 "嵌套的" 事务, 它是已经存在事务的一个真正的子事务. 嵌套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 嵌套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.
代码例子:
@Transactional(propagation=Propagation.NESTED)
@Transactional(propagation=Propagation.PROPAGATION_REQUIRES_NEW)
ServiceA{
@Autowired
ServiceB serviceB;
@Transactional(propagation=Propagation.NESTED)
public void method1(){
serviceB.method2();
int i = 1/0;
}
}
ServiceB{
@Transactional(propagation=Propagation.NESTED)
public void method2(){
xxxxxx
}
}
因为method1使用 @Transactional(propagation=Propagation.NESTED),当执行method1时,会抛出异常,method2()也会被回滚;
如果method2()用PROPAGATION_REQUIRES_NEW:
ServiceB{
@Transactional(propagation=Propagation.PROPAGATION_REQUIRES_NEW)
public void method2(){
xxxxxx
}
}
那么method2不会因为method1抛出异常而回滚。
不管是什么类型的嵌套事务,一个线程只有一个事务,线程结束的时候才提交事务,包括嵌套事务,即使嵌套事务是REQUIRES_NEW,也不是嵌套事务的方法结束就提交事务的,一定是等到外部事务方法结束,整个线程结束才一起提交的。
在相同线程中进行相互嵌套调用的事务方法工作于相同的事务中。如果这些相互嵌套调用的方法工作在不同的线程中,则不同线程下的事务方法工作在独立的事务中。
而锁存在于事务里,锁的生命周期也是一个线程,在一个线程里可多次取得同一个锁。
如果事务加在外部方法A,在内部方法里面有synchronized代码块B,那么当B执行完时,事务还未提交,其他线程进入synchronized代码块B后,读取的库存数据不是最新的。
--结束END--
本文标题: Spring事务处理Transactional,锁同步和并发线程
本文链接: https://www.lsjlt.com/news/161247.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑,方便收藏和打印~
2024-03-01
2024-03-01
2024-03-01
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
0