传播行为 来确定的。MySQL数据库本身不支持嵌套事务，因此Spring的“嵌套事务”是通过MySQL的Savepoint保存点来实现的 。如果使用声明式事务管理，那么Spring采用的是AOP来支持事务管理，在方法前会根据配置的事务属性来决定是否需要通过AOP拦截器来开启一个事务。因此，传播行为主要是针对声明式事务管理的扩展 。Spring提供了七种事务的传播行为（当前事务是指调用者自带的事务，A调用B，那么A的事务就是当前事务） ： PROPAGATION_REQUIRED：Spring默认的传播行为，如果当前存在事务（即A方法存在事务），则加入到当前事务，使用当前外层事务的属性；如果当前不存在事务，就创建一个新事务运行。 PROPAGATION_SUPPORTS：如果当前存在事务，则加入到当前事务中去；如果当前不存在事务，则直接以非事务的方式执行。 PROPAGATION_MANDATORY：如果当前存在事务，则加入到当前事务中去；如果当前不存在事务，则直接抛出异常new IllegalTransactionStateException(“No existing transaction found for transaction marked with propagation ‘mandatory’”) 。 PROPAGATION_REQUIRES_NEW：新建一个事务独立运行，如果当前存在事务就将当前事务挂起，内层事务结束时，外层事务将继续执行；内层事务可以独立提交或回滚，外层事务不受内层事务的回滚状态的影响 。 PROPAGATION_NOT_SUPPORTED：以非事务方式执行，如果当前存在事务就将当前事务挂起，执行完当前代码后，才恢复外层事务。 PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务就抛出异常new IllegalTransactionStateException(“Existing transaction found for transaction marked with propagation ‘never’”) 。 PROPAGATION_NESTED：新建一个事务，如果当前存在事务就嵌套在当前事务内执行；如果当前不存在事务，则等价于PROPAGATION_REQUIRED会新建一个事务运行。
TransactionDefinition.PROPAGATION_REQUIRED=0 ；如果当前存在事务，则加入到当前事务，使用当前外层事务的属性；如果当前不存在事务，就创建一个新事务运行。
加入 的解释：表示使用同一个物理事务，内部的事务（即B方法的事务）将会忽略自己设置的隔离级别、超时时间、只读标识这几个属性，这些属性统一使用最外层事务方法设置的值（即A方法的事务属性）。
@Transactional ( propagation = Propagation . REQUIRED)
public void A ( ) {
B ( ) ;
}
@Transactional ( propagation = Propagation . REQUIRED)
public void B ( ) {
}
TransactionDefinition.PROPAGATION_SUPPORTS=1 ；如果当前存在事务，则加入到当前事务中去；如果当前不存在事务，则直接以非事务的方式执行。
TransactionDefinition.PROPAGATION_SUPPORTS=2 ；如果当前存在事务，则加入到该事务中去；如果当前不存在事务，则直接抛出异常new IllegalTransactionStateException(“No existing transaction found for transaction marked with propagation ‘mandatory’”) 。
TransactionDefinition.PROPAGATION_REQUIRES_NEW=3 ；新建一个事务独立运行，如果当前存在事务就将当前事务挂起，内层事务结束时，外层事务将继续执行；内层事务可以独立提交或回滚，外层事务不受内层事务的回滚状态的影响。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED=4 ；以非事务方式执行，如果当前存在事务就将当前事务挂起，执行完当前代码后，则恢复外层事务。
TransactionDefinition.PROPAGATION_NEVER=5 ；以非事务方式执行，如果当前存在事务就抛出异常new IllegalTransactionStateException(“Existing transaction found for transaction marked with propagation ‘never’”) 。与PROPAGATION_MANDATORY正好相反。
TransactionDefinition.PROPAGATION_NESTED=6 ；如果当前存在事务，则新建一个事务作为当前事务的嵌套事务来运行；如果当前不存在事务，则等价于PROPAGATION_REQUIRED会新建一个事务运行。对嵌套事务的解释： 嵌套事务实际上是通过保存点（SavePoint）来实现的，这个保存点属于当前已存在的外层事务，所以说仍然只有一个物理事务，这就是真正的嵌套事务的实现 。 基于保存点的特性，内层事务依赖外层事务（实际上是同一个事务）。内层事务操作失败时只是自身回到保存点的位置，不会引起外层事务的回滚；而外层事务因失败回滚时，内层事务也会跟着一起回滚；在提交时，在外层事务提交之后，内层事务才能提交，只需要提交外层事务即可 。 由于实际上只有一个物理事务，那么内层事务会继承外层事务的隔离界别和超时时间、只读标记等属性 。 要想使用嵌套事务还需要把AbstractPlatformTransactionManager的nestedTransactionAllowed属性设为true（默认为false），但是DataSourceTransactionManager的构造方法中会将nestedTransactionAllowed设置为true 。
丢失更新（Lost Update）：当两个或多个事务选择同一行，然后基于最初选定的值更新该行时，由于每个事务都不知道其他事务的存在，就会发生丢失更新问题，最后的更新覆盖了由其他事务所做的更新。脏读（Dirty Reads）：事务A读取到了事务B已修改但尚未提交的的数据，但是事务B由于某种原因取消对数据的修改（即事务回滚），此时事务A读取的数据与数据库中数据不一致，不符合一致性要求。不可重复读（Non-Repeatable Reads）：事务A读取数据库中的数据后，事务B进行修改或删除并提交了符合事务A查询条件的数据，当事务A再次执行同一查询时，就会发现数据前后不一致，这就是不可重复读；即不可重复读发生在一个事务执行两次或两次以上的相同查询时，查询结果不一致。幻读（Phantom Reads）：事务A读取数据库中的数据后，事务B进行插入并提交了符合事务A查询条件的数据，当事务A再次执行同一查询时，就会发现多出来了数据，这就是幻读；即幻读发生在一个事务执行两次或两次以上的相同查询时，查询结果不一致。
读未提交（Read Uncommitted）： 此隔离级别可防止丢失更新，但是存在脏读、不可重复读、幻读的问题 。 写事务阻止其他写事务，避免了丢失更新，但是没有阻止其他读事务；读事务则不会阻止其他任何事务 。 读已提交（Read Committed）： 解决了脏读问题，但是可能会出现不可重复读和幻读的问题 。 写事务会阻止其他读写事务；读事务不会阻止其他任何事务 。 可重复读（Repeatable Read）： 写事务会阻止其他读写事务；读事务会阻止其他写事务，但不会阻止其他读事务；可重复读阻止的写事务只包括update、delete操作，不包括insert操作，因此可能出现幻读，但这不是绝对的 。 实际上，MySQL在默认的可重复读隔离级别下，通过MVCC解决了幻读问题 。 序列化/串行化（Serializable）： 最高的事务隔离级别。它通过强制事务串行化顺序执行，避免了脏读、幻读、不可重复读问题 。 它会在读取的每一行数据上都加锁，所以可能导致大量的超时和竞争锁问题，严重影响程序性能，实际应用中很少使用到这个隔离级别，只有在非常需要确保数据的一致性而且可以接受没有并发的情况下，才考虑使用 。 隔离级别 脏读 不可重复度 幻读 读未提交（Read Uncommitted） 是 是 是 读已提交（Read Committed） 否 是 是 可重复读（Repeatable Read） 否 否 是 可串行化（Serializable） 否 否 否
ISOLATION_DEFAULT：值为-1，是PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别。ISOLATION_READ_UNCOMMITTED：值为1，对应Read Uncommitted（读未提交），最低的事务隔离级别。ISOLATION_READ_COMMITTED：值为2，对应Read Committed（读已提交）。ISOLATION_REPEATABLE_READ：值为4，对应Repeatable Read（可重复读）。ISOLATION_SERIALIZABLE：值为8，对应Serializable（可串行化），最高的事务隔离级别。
事务的隔离级别是在一个事务启动的时候设置的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、ROPAGATION_NESTED）的方法来说，声明的事务隔离级别参数才有意义。
@Service
public class IsolationServiceImpl {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private IsolationServiceImpl isolationService;
@Transactional
public User readUncommitIsolation ( User user) {
String sql = "insert into users (name, age) values (?,?)" ;
jdbcTemplate. update ( sql, user. getName ( ) , user. getAge ( ) ) ;
User readUncommit = isolationService. getReadUncommit ( user. getName ( ) ) ;
System . out. println ( "查询事务返回的数据：" + readUncommit) ;
return readUncommit;
}
@Transactional ( propagation = Propagation . REQUIRES_NEW, isolation = Isolation . READ_UNCOMMITTED)
public User getReadUncommit ( String name) {
String sql = "select * from users where name = ?" ;
User user = jdbcTemplate. queryForObject ( sql, BeanPropertyRowMapper . newInstance ( User . class ) , name) ;
return user;
}
@Transactional
public User defaultIsolation ( User user) {
String sql = "insert into users (name, age) values (?,?)" ;
jdbcTemplate. update ( sql, user. getName ( ) , user. getAge ( ) ) ;
User readUncommit = getDefault ( user. getName ( ) ) ;
System . out. println ( "查询事务返回的数据：" + readUncommit) ;
return readUncommit;
}
@Transactional ( propagation = Propagation . REQUIRES_NEW)
public User getDefault ( String name) {
String sql = "select * from users where name = ?" ;
User user = jdbcTemplate. queryForObject ( sql, BeanPropertyRowMapper . newInstance ( User . class ) , name) ;
return user;
}
}
@RunWith ( SpringJUnit4ClassRunner . class )
@ContextConfiguration ( classes = DataSourceAnnoConfig . class )
public class Test6 {
@Autowired
private IsolationServiceImpl isolationService;
@Test
public void test01 ( ) {
User user = isolationService. readUncommitIsolation ( new User ( "喜羊羊" , 29 ) ) ;
}
@Test
public void test02 ( ) {
User user = isolationService. defaultIsolation ( new User ( "沸羊羊" , 29 ) ) ;
}
}
@Service
public class TimeOutAndReadOnlyAndRollbackServiceImpl {
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional ( timeout = 1 )
public int timeOut ( User user) {
DefaultTransactionStatus transactionStatus = ( DefaultTransactionStatus ) TransactionAspectSupport . currentTransactionStatus ( ) ;
try {
Thread . sleep ( 5000 ) ;
} catch ( InterruptedException e) {
e. printStackTrace ( ) ;
}
String insertSQL = "insert into users (name, age) values (?,?)" ;
int update = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
return update;
}
}
@RunWith ( SpringJUnit4ClassRunner . class )
@ContextConfiguration ( classes = DataSourceAnnoConfig . class )
public class Test7 {
@Autowired
private TimeOutAndReadOnlyAndRollbackServiceImpl otherService;
@Test
public void test01 ( ) {
int i = otherService. timeOut ( new User ( "慢羊羊" , 29 ) ) ;
}
}
通过上面两种情况可以得出这样的结论： 如果将休眠时间放到插入操作后面，超时之后并没有报错，也就没有事务回滚这一说法，同时数据库中会插入一条记录，说明超时时间指的是数据库执行最多能用的时间，不是Java程序执行的时间。 Spring事务超时时间 = 事务开始时到最后一个Statement创建时时间 + 最后一个Statement的执行完的时间。这也说明了为什么休眠代码放到插入操作代码前面时候，会超时且回滚了。
readOnly=true，默认为false，表示只读事务。在oracle下测试，发现不支持readOnly属性，也就是不论Connection里的readOnly属性是true还是false均不影响SQL的增删改查。改为使用Oracle配置，只读事务中进行插入操作，数据库中成功插入一条数据，只读事务没有生效
改为使用MySQL配置，只读事务中进行插入操作会报错，只读事务生效
< dependency> < groupId> </ groupId> < artifactId> </ artifactId> < version> </ version> </ dependency> # oracle连接信息配置
url=jdbc:oracle:thin:@//192.168.1.7:1521/orcl
className=oracle.jdbc.driver.OracleDriver
userName=kolonfair2
password=tgbyhn624
@Configuration
@ComponentScan ( "com.itan.transactional.anno.*" )
@PropertySource ( value = "classpath:oracle.properties" , encoding = "UTF-8" )
@EnableTransactionManagement
public class OracleDataSourceConfig {
@Value ( "${url}" )
private String url;
@Value ( "${className}" )
private String className;
@Value ( "${userName}" )
private String userName;
@Value ( "${password}" )
private String password;
@Bean
public DruidDataSource druidDataSource ( ) {
DruidDataSource dataSource = new DruidDataSource ( ) ;
dataSource. setUrl ( url) ;
dataSource. setDriverClassName ( className) ;
dataSource. setUsername ( userName) ;
dataSource. setPassword ( password) ;
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate ( ) {
return new JdbcTemplate ( druidDataSource ( ) ) ;
}
@Bean
public DataSourceTransactionManager transactionManager ( ) {
return new DataSourceTransactionManager ( druidDataSource ( ) ) ;
}
}
@Transactional ( readOnly = true )
public int oracleReadOnly ( User user) {
String insertSQL = "insert into user_test (id, name, age) values (1, ?, ?)" ;
int update = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
String querySQL = "select * from users where name = ?" ;
User user1 = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , user. getName ( ) ) ;
System . out. println ( user1) ;
return update;
}
@RunWith ( SpringJUnit4ClassRunner . class )
@ContextConfiguration ( classes = OracleDataSourceConfig . class )
public class Test8 {
@Autowired
private TimeOutAndReadOnlyAndRollbackServiceImpl otherService;
@Test
public void test01 ( ) {
int i = otherService. oracleReadOnly ( new User ( "慢羊羊" , 29 ) ) ;
}
}
受检异常（除了RuntimeException和Error之外的异常）时不会回滚，因为受检异常可能是作为一个业务异常而代替返回值的结果，因此，如果遇到了受检异常，仍然会提交事务。可以声明在出现特定受检查异常时像运行时异常一样回滚，也可以声明一个事务在出现特定的异常时不回滚，即使特定的异常是运行时异常。回滚规则可以通过@Transactional注解的rollbackFor属性和noRollbackFor属性，以及<tx:method>标签的rollback-for和no-rollback-for属性来设置。注意： 如果回滚和不回滚属性设置了相同的异常，那么在抛出该异常时将会回滚。 如果抛出的异常没有匹配设定的异常，那么会采用默认规则，即异常属于RuntimeException或Error级别的异常时，才会回滚。
@Transactional
public int checkedException ( User user) throws IOException {
String insertSQL = "insert into users (name, age) values (?,?)" ;
int update = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
String querySQL = "select * from users where name = ?" ;
User user1 = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , user. getName ( ) ) ;
System . out. println ( user1) ;
throw new IOException ( ) ;
}
@Transactional
public int uncheckedException ( User user) {
String insertSQL = "insert into users (name, age) values (?,?)" ;
int update = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
String querySQL = "select * from users where name = ?" ;
User user1 = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , user. getName ( ) ) ;
System . out. println ( user1) ;
int i = 1 / 0 ;
return update;
}
@Transactional ( rollbackFor = IOException . class )
public int checkedExceptionRollback ( User user) throws IOException {
String insertSQL = "insert into users (name, age) values (?,?)" ;
int update = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
String querySQL = "select * from users where name = ?" ;
User user1 = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , user. getName ( ) ) ;
System . out. println ( user1) ;
throw new IOException ( ) ;
}
@Transactional ( rollbackFor = ArithmeticException . class , noRollbackFor = ArithmeticException . class )
public int rollbackAndNoRollbackExceptionSame ( User user) {
String insertSQL = "insert into users (name, age) values (?,?)" ;
int update = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
String querySQL = "select * from users where name = ?" ;
User user1 = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , user. getName ( ) ) ;
System . out. println ( user1) ;
int i = 1 / 0 ;
return update;
}
当前类自己注入自己，实际上注入的是一个代理对象，然后就可以使用这个注入的代理对象去调用内层方法了。 对于XML配置方式，设置<aop:config>或者<aop:aspectj-autoproxy>标签的expose-proxy属性为true；对于注解配置方式，则设置@EnableAspectJAutoProxy注解的exposeProxy属性为true，其目的就是将代理对象暴露出来，然后代码中使用AopContext.currentProxy()即可获取代理对象，然后强制转型去调用内层方法即可（注意类型兼容性）。 将方法放到不同的类中，跨类调用。
public interface TransactionalLapseService {
User getUser ( User user) ;
int insertUser ( User user) ;
int updateUser ( User user) ;
}
@Service
public class TransactionalLapseServiceImpl implements TransactionalLapseService {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public User getUser ( User user) {
String querySQL = "select * from users where name = ?" ;
User one = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , user. getName ( ) ) ;
one. setAge ( user. getAge ( ) ) ;
updateUser ( one) ;
return one;
}
@Override
@Transactional
public int updateUser ( User user) {
String updateSQL = "update users set age = ? where name = ?" ;
int update = jdbcTemplate. update ( updateSQL, user. getAge ( ) , user. getName ( ) ) ;
throw new RuntimeException ( ) ;
}
}
@RunWith ( SpringJUnit4ClassRunner . class )
@ContextConfiguration ( classes = DataSourceAnnoConfig . class )
public class Test9 {
@Autowired
private TransactionalLapseService transactionalLapseService;
@Test
public void test01 ( ) {
transactionalLapseService. getUser ( new User ( "同一类方法相互调用" , 100 ) ) ;
}
}
private/final/static等关键字修饰了，那么在它的代理类中，就无法重写被这些关键字修饰的方法，Spring也就无法将事务控制的代码逻辑织入方法代码中，事务也就失效了。 注意：如果将事务注解的方法使用private/final/static修饰，在修改的时候就会提醒：Methods annotated with '@Transactional' must be overridable
REQUIRED，REQUIRES_NEW，NESTED这三种的方法才会创建新事务；如果传播行为设置成这三种之外的，那么该方法也就不会被事务管理了，事务也就失效了。
MyISAM存储引擎，因为MyISAM存储引擎本身不支持事务，因此事务毫无疑问会失效。
如果想要spring事务能够正常回滚，必须抛出它能够处理的异常。如果没有抛异常，则Spring认为程序是正常的；默认情况下只会回滚RuntimeException（运行时异常）和Error（错误），对于普通的Exception（非运行时异常），它不会回滚。
@Override
@Transactional
public int insertUser ( User user) {
int insert = 0 ;
try {
String insertSQL = "insert into users (name, age) values (?,?)" ;
insert = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
System . out. println ( "插入操作受影响行数：" + insert) ;
int i = 1 / 0 ;
} catch ( Exception e) {
e. printStackTrace ( ) ;
}
return insert;
}
@Override
@Transactional
public int throwExceptionTypeIsIncorrect ( User user) throws Exception {
int insert = 0 ;
try {
String insertSQL = "insert into users (name, age) values (?,?)" ;
insert = jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
System . out. println ( "插入操作受影响行数：" + insert) ;
int i = 1 / 0 ;
} catch ( Exception e) {
throw new Exception ( e. getMessage ( ) ) ;
}
return insert;
}
这是因为两个方法不在同一个线程中，Spring实现事务的原理是通过ThreadLocal把数据库连接绑定到当前线程中，因此获取到的数据库连接不一样，不是同一个事务；同一事务是指同一个数据库连接，只有使用相同的数据库连接才能同时提交和回滚事务。
@Service
public class ThreadTransactional {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private ThreadTransactional threadTransactional;
@Transactional
public int threadTransactionalMethod ( User user) {
String updateSQL = "update users set age = ? where name = ?" ;
int update = jdbcTemplate. update ( updateSQL, user. getAge ( ) , user. getName ( ) ) ;
user. setName ( "线程调用" ) ;
user. setAge ( 30 ) ;
new Thread ( ( ) -> threadTransactional. doOtherThing ( user) ) . start ( ) ;
return 0 ;
}
@Transactional
public void doOtherThing ( User user) {
String insertSQL = "insert into users (name, age) values (?,?)" ;
jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
int i = 1 / 0 ;
}
}
@Test
public void test04 ( ) {
threadTransactional. threadTransactionalMethod ( new User ( "抛出异常类型不正确" , 100 ) ) ;
}
一个事务方法调用一个传播行为是Propagation.NESTED（嵌套事务）的方法时，当被调用的嵌套事务方法中发生异常，且没有手动捕获异常，异常会继续往上抛出，到外层的调用方法中，这种情况是直接回滚了整个事务，不是回滚单个保存点。解决方法：将内部嵌套事务放在try/catch中，并且不继续往上抛异常。这样就能保证，如果内部嵌套事务中出现异常，只回滚内部事务，而不影响外部事务。
@Service
public class NestedTransactional {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private NestedTransactional nestedTransactional;
@Transactional
public int nestedTransactionalMethod ( User user) {
String updateSQL = "update users set age = ? where name = ?" ;
int update = jdbcTemplate. update ( updateSQL, user. getAge ( ) , user. getName ( ) ) ;
user. setName ( "线程调用" ) ;
user. setAge ( 30 ) ;
nestedTransactional. doOtherThing ( user) ;
return 0 ;
}
@Transactional ( propagation = Propagation . NESTED)
public void doOtherThing ( User user) {
String insertSQL = "insert into users (name, age) values (?,?)" ;
jdbcTemplate. update ( insertSQL, user. getName ( ) , user. getAge ( ) ) ;
int i = 1 / 0 ;
}
}
问题现象：在高并发情况下，且事务隔离级别设置为可重复读（REPEATABLE_READ）时，如果Spring事务中包含锁的情况（使用Java锁或Redis锁），会造成读取的数据不是最新的情况，如果后续的逻辑要依赖读取到的数据，可能会造成最后结果与预期的不一致。
@Slf4j
@Service
public class LockAndTransactional {
private ReentrantLock lock = new ReentrantLock ( true ) ;
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void addQty ( String name) {
lock. lock ( ) ;
try {
log. info ( "线程：{}，获取锁成功" , Thread . currentThread ( ) . getName ( ) ) ;
String querySQL = "select * from users where name = ?" ;
User user = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , name) ;
Integer qty = user. getQty ( ) ;
log. info ( "线程：{}，查询的原始订量为：{}" , Thread . currentThread ( ) . getName ( ) , qty) ;
qty = qty + 1 ;
String updateSQL = "update users set qty = ? where id = ?" ;
int update = jdbcTemplate. update ( updateSQL, qty, user. getId ( ) ) ;
log. info ( "线程：{}，修改订量完成，修改后的订量为：{}" , Thread . currentThread ( ) . getName ( ) , qty) ;
} finally {
lock. unlock ( ) ;
log. info ( "线程：{}，释放锁成功" , Thread . currentThread ( ) . getName ( ) ) ;
}
}
public User getQty ( String name) {
String querySQL = "select id, name, age, qty from users where name = ?" ;
User user = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , name) ;
return user;
}
}
@RunWith ( SpringJUnit4ClassRunner . class )
@ContextConfiguration ( classes = DataSourceAnnoConfig . class )
public class Test10 {
@Autowired
private LockAndTransactional lockAndTransactional;
@Test
public void test1 ( ) throws InterruptedException {
User user = lockAndTransactional. getQty ( "张三" ) ;
System . out. println ( "递增之前的结果：" + user) ;
CountDownLatch countDownLatch = new CountDownLatch ( 20 ) ;
for ( int i = 0 ; i < 20 ; i++ ) {
final int k = i;
new Thread ( ( ) -> {
lockAndTransactional. addQty ( "张三" ) ;
countDownLatch. countDown ( ) ;
} , "线程" + ( k + 1 ) ) . start ( ) ;
}
countDownLatch. await ( ) ;
user = lockAndTransactional. getQty ( "张三" ) ;
System . out. println ( "递增之后的结果：" + user) ;
}
}
释放锁的顺序是在事务提交之前，但是无法知道获取锁是在事务开始之前还是之后。
select * from information_schema.innodb_trx;语句查询当前数据库有哪些事务正在执行的语句，再配合DEBUG模式就能知道开始事务与加锁的先后顺序。 说明加锁在事务开启之前。 说明事务这才真正开启，也即只有遇到对数据库操作的时候才会真正开启事务。
加锁->遇到第一个对数据库的操作时开启事务->执行业务->释放锁->提交事务
正确使用锁，把整个事务放在锁的工作范围之内，这样就能保证事务的提交一定是在释放锁之前了。 将隔离级别设置为串行化Isolation.SERIALIZABLE，都不需要使用加锁逻辑了，但是性能会跟不上，不建议使用。
@Slf4j
@Service
public class LockAndTransactional {
private ReentrantLock lock = new ReentrantLock ( true ) ;
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private LockAndTransactional lockAndTransactional;
public void transactionsUseLocksCorrectly ( String name) {
lock. lock ( ) ;
try {
log. info ( "线程：{}，获取锁成功" , Thread . currentThread ( ) . getName ( ) ) ;
lockAndTransactional. addQty ( name) ;
} finally {
lock. unlock ( ) ;
log. info ( "线程：{}，释放锁成功" , Thread . currentThread ( ) . getName ( ) ) ;
}
}
@Transactional
public void addQty ( String name) {
String querySQL = "select * from users where name = ?" ;
User user = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , name) ;
Integer qty = user. getQty ( ) ;
log. info ( "线程：{}，查询的原始订量为：{}" , Thread . currentThread ( ) . getName ( ) , qty) ;
qty = qty + 1 ;
String updateSQL = "update users set qty = ? where id = ?" ;
int update = jdbcTemplate. update ( updateSQL, qty, user. getId ( ) ) ;
log. info ( "线程：{}，修改订量完成，修改后的订量为：{}" , Thread . currentThread ( ) . getName ( ) , qty) ;
}
public User getQty ( String name) {
String querySQL = "select id, name, age, qty from users where name = ?" ;
User user = jdbcTemplate. queryForObject ( querySQL, BeanPropertyRowMapper . newInstance ( User . class ) , name) ;
return user;
}
}
@RunWith ( SpringJUnit4ClassRunner . class )
@ContextConfiguration ( classes = DataSourceAnnoConfig . class )
public class Test10 {
@Autowired
private LockAndTransactional lockAndTransactional;
@Test
public void test1 ( ) throws InterruptedException {
User user = lockAndTransactional. getQty ( "张三" ) ;
System . out. println ( "递增之前的结果：" + user) ;
CountDownLatch countDownLatch = new CountDownLatch ( 20 ) ;
for ( int i = 0 ; i < 20 ; i++ ) {
final int k = i;
new Thread ( ( ) -> {
lockAndTransactional. transactionsUseLocksCorrectly ( "张三" ) ;
countDownLatch. countDown ( ) ;
} , "线程" + ( k + 1 ) ) . start ( ) ;
}
countDownLatch. await ( ) ;
user = lockAndTransactional. getQty ( "张三" ) ;
System . out. println ( "递增之后的结果：" + user) ;
}
}
1426
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
