Spring事务管理实现原理及MySQL InnoBD引擎行锁概述

最新推荐文章于 2022-12-28 17:32:10 发布
最新推荐文章于 2022-12-28 17:32:10 发布
阅读量287 收藏
点赞数
文章标签： java 数据库
原文链接：https://my.oschina.net/u/1048116/blog/668252
版权

Spring实现事务管理的机制

Spring事务管理是基于AOP编程思想实现，Spring框架被广泛使用的原因之一，就是提供了强大的事务管理机制。

AOP是什么？我们常说的AOP并不是指一种开发技术，而是一种编程思想，AOP的核心概念就是面向切面编程，实现可插拔，降低程序之前的耦合性，提高重用性。

Spring AOP 基于动态代理实现，一种是JDK动态代理，另一种是CGLIB动态代理。

spring2.5之前声明式事务可以这样实现：

​<!-- 声明使用的spring事务管理器-->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
    <property name="dataSource" ref="dataSource" />  
</bean>  
<tx:advice id="txAdvice" transaction-manager="txManager">  
    <tx:attributes>  
        <tx:method name="get*" read-only="true" />
        <tx:method name="add*" propagation="REQUIRED"/>
    </tx:attributes>  
</tx:advice>  
<aop:config proxy-target-class="true">  
    <aop:advisor advice-ref="txAdvice"   
    pointcut="execution(* com.junlong.demo.service.DemoService.*(..))"/>  
</aop:config>

在spring2.5之后声明式事务，增加了<tx:annotation-driven />事务注解驱动，这样可以更灵活的控制在哪声明事务，并且Spring2.5之后的一个核心主题就是全面的支持注解方式

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean> 
<tx:annotation-driven />

 

几个核心的注意事项

一、Spring事务管理基于动态代理的两种方式（JDKProxy、CGLIBProxy）

<tx:annotation-driven transaction-manager="transactionManager" />

1.如果代理对象实现了接口则采用JDK动态代理实现，JDK动态代理基于接口进行代理的，它是通过在运行时创建一个接口的实现类来完成对目标对象的代理，所以使用@Transactional 注解的类想要基于JDK动态代理进行事务控制必须实现一个接口。

Spring默认会在JDK动态代理和CGLIB动态代理之间进行切换，如果被代理的类实现了接口则会使用JDK动态代理，否则会使用CGLIB动态代理。

如果想强制使用基于类的代理，可以设置proxy-target-class=true，这样Spring会使用CGLIB代理，在使用CGLIB代理时@Transactional必须写在具体的实现类上或者实现方法上，因为CGLIB动态代理是在运行时对代理对象进行继承扩展子类，所以声明final的类是无法使用CGLIB代理的。

<xsd:attribute name="proxy-target-class" type="xsd:boolean" default="false">
    <xsd:annotation>
        <xsd:documentation>
            <![CDATA[
            	Are class-based (CGLIB) proxies to be created? By default, standard
            	Java interface-based proxies are created.
            
            	Note: Class-based proxies require the @Transactional annotation to be
            	defined on the concrete class. Annotations in interfaces will not work
            	in that case (they will rather only work with interface-based proxies)!
        	]]>
        </xsd:documentation>
    </xsd:annotation>
</xsd:attribute>

2.官方文档介绍@Transactional 注解只有在public的方法上生效，这是因为Spring事务注解驱动是基于Spring AOP（也就是默认的方式是基于动态代理实现）实现的。

3.同一个java类内部方法调用本类内部的其他方法并不会引起事务行为，即使被调用方法使用@Transactional注解进行修饰，这也是因为Spring实现事务代理是默认是基于Spring AOP（也就是默认的方式是基于动态代理实现）实现的。

二、Spring事务管理实现的两种方式（动态代理、静态编织）

<tx:annotation-driven transaction-manager="transactionManager" mode="proxy" />

<xsd:attribute name="mode" default="proxy">
    <xsd:annotation>
        <xsd:documentation>
        <![CDATA[
        	Should annotated beans be proxied using Spring's AOP framework,
        	or should they rather be weaved with an AspectJ transaction aspect?
        
        	AspectJ weaving requires spring-aspects.jar on the classpath,
        	as well as load-time weaving (or compile-time weaving) enabled.
        
        	Note: The weaving-based aspect requires the @Transactional annotation to be
        	defined on the concrete class. Annotations in interfaces will not work
        	in that case (they will rather only work with interface-based proxies)!
        ]]>
        </xsd:documentation>
    </xsd:annotation>
    <xsd:simpleType>
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="proxy"/>
            <xsd:enumeration value="aspectj"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:attribute>

mode模式默认采用代理模式(mode="proxy")，在proxy模式中采用AOP的动态代理来进行事务管理，是在运行期间基于JDK动态代理或者GCLIB动态代理来实现，在代理模式中(mode="proxy")只有A类中方法调用另外一个B类声明@Transactional的方法才会被代理截获进行事务控制，在A类本类中调用本类的其他带有@Transactional的方法不会经过动态代理。

然而mode="aspectj"则采用静态编织的方式（aspectj是一种编译技术）其需要spring-aspects.jar，是在编译期间或者载入期间对代理对象进行修改字节码织入事务实现，所以不管你的方法的可见度（public、private）是什么都可以实现事务管理，这跟proxy动态代理是完全不同的。

<tx:annotation-driven />，其实是Spring自定义标签的扩展，Spring配置文件中的标签都是基于XML Schema实现 ，spring的实现：http://www.springframework.org/schema/tx/spring-tx-4.1.xsd

Propagation Spring事务传播行为

事务传播行为描述
REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择
SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行
MANDATORY支持当前事务,如果没有抛出异常
REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起
NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
NEVER以非事务方式执行，如果当前存在事务，则抛出异常
NESTED执行在一个嵌套的事务,如果当前事务存在,执行类似REQUIRED操作

readOnly 

如果事务是只读的使用该属性，默认他是false

timeout

默认为底层事务系统的默认超时

Isolation

指定事务隔离级别，默认使用数据库底层配置的事务隔离级别

参考资料：

spring2.5开始对事务注解驱动的支持 https://spring.io/blog/2008/01/28/spring-2-5-s-comprehensive-annotation-support

Spring Framework 开发参考手册 http://shouce.jb51.net/spring/ 

《Spring3.x企业应用开发实战》

配套代码：

https://github.com/chenjunlong/spring-transaction-manager

MySQL InnoDB存储引擎锁概述

排它锁    

排它锁又称为写锁（(eXclusive lock,简记为X锁)），若事务T对数据对象A加上X锁，则只允许T读取和修改A，其它任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。它防止任何其它事务获取资源上的锁，直到在事务的末尾将资源上的原始锁释放为止。

在更新操作（INSERT、UPDATE 或 DELETE）过程中始终应用排它锁。

共享锁

共享锁又称为读锁（Share lock,简记为S锁），若事务T对数据对象A加上S锁，则其它事务只能再对A加S锁，而不能加X锁，直到T释放A上的S锁。

MySQL InnoBD存储引擎行锁的三种算法

Record Lock：单个行记录上的锁

Gap Lock：间隙锁，锁定一个范围，但不包含记录本身

Next-Key Lock：Gap Lock + Record Lock，锁定一个范围，并且锁定记录本身，Record Lock总是会去锁住索引记录，如果表没有设置任何一个索引，会使用隐式的主键进行锁定。

InnoDB存储引擎默认的事务隔离级别REPEATABLE READ，在事务隔离级别下，采用Next-key Locking的方式进行加锁。

而在，READ COMMITTED下，仅采用Record Lock。

然而在 REPEATABLE READ 级别 InnoDB存储引擎下，查询使用含有唯一属性时，会对Next-Key Lock 进行优化，将其降级为Record Lock，即锁住索引本身，而不是一个范围。

一致性非锁定读

一致性的非锁定读是指InnoDB存储引擎通过行多版本控制方式读取当前执行的时间数据库中行的数据。

例如：

    如果读取的行正在执行DELETE或UPDATE操作，这时读取操作不会因此等待行上的锁释放掉，而是去读取该行数据的一个快照行数据。这种非锁定读机制极大的提高了数据库的并发性，这是InnoDB存储引擎默认的读取方式，即读取不会占用等待数据行的锁。

    在事务隔离级别RC和RR对快照数据的定义有所不同，在RC下对于快照数据，非一致性锁定读总是读取被锁定行最新的一条数据快照（这种做法显然不符合事务的隔离性），而在RR下对于快照数据，非一致性锁定读总是读取事务开始时的行数据快照。

 

一致性锁定读，MySQL显示加锁的语句

在某些业务场景下，需要显示的对数据库读取操作进行加锁操作，来保证业务逻辑数据的一致性，这种做法被称为一致性锁定读。

SELECT...FOR UPDATE 为记录加一个X锁。

SELECT...LOCK IN SHARE MODE 为记录加一个S锁。

必须嵌套在事务中，事务结束锁释放

下面主要介绍X锁和显示的加X锁

存储引擎：InnoDB ，事务隔离级别：REPEATABLE-READ

例：

CREATE TABLE `USER` (

  `ID` int(11) NOT NULL AUTO_INCREMENT,

  `MOBILE` varchar(11) DEFAULT NULL,

  `NAME` varchar(255) DEFAULT NULL,

  PRIMARY KEY (`ID`)

) ENGINE=InnoDB AUTO_INCREMENT=322 DEFAULT CHARSET=utf8;

INSERT INTO `USER` VALUES ('222', '13121771001', 'test1001');

INSERT INTO `USER` VALUES ('223', '13121771002', 'test1002');

INSERT INTO `USER` VALUES ('224', '13121771003', 'test1003');

INSERT INTO `USER` VALUES ('225', '13121771004', 'test1004');

INSERT INTO `USER` VALUES ('226', '13121771005', 'test1005');

INSERT INTO `USER` VALUES ('227', '13121771006', 'test1006');

INSERT INTO `USER` VALUES ('228', '13121771007', 'test1007');

INSERT INTO `USER` VALUES ('229', '13121771008', 'test1008');

INSERT INTO `USER` VALUES ('230', '13121771009', 'test1009');

INSERT INTO `USER` VALUES ('231', '13121771010', 'test1010');

 

一、以主键为查询条件

下面以主键为条件锁住一行数据

会话A会话B

BEGIN;

SELECT * FROM USER WHERE ID = 222 FOR UPDATE;

重新打开一个查询分析器，查询相同记录，发现行已被锁

 

BEGIN;

SELECT * FROM USER WHERE ID = 222 FOR UPDATE;

172217_ajQ6_1048116.png172410_B3xH_1048116.png
 

查询不相同记录，发现行未被锁，证明是行锁

 

BEGIN;

SELECT * FROM USER WHERE ID = 223 FOR UPDATE;


172507_Rpna_1048116.png

结论：以主键为查询条件的为行锁，不会影响其他行，相同行查询会产生等待。

超时异常： 1205 - Lock wait timeout exceeded; try restarting transaction

 

 

二、以唯一字段为查询条件(未加唯一约束)

会话A会话B

BEGIN;

SELECT * FROM `USER` WHERE MOBILE = '13121771001' FOR UPDATE;

重新打开一个查询分析器，查询不相同记录，发现表以被锁

 

BEGIN;

SELECT * FROM `USER` WHERE MOBILE = '13121771002' FOR UPDATE;

172802_g3iR_1048116.png172844_34Nh_1048116.png
  

结论：以普通列查询，未加唯一约束的情况下，即使返回唯一一行，也会造成全表锁。

 

三、增加唯一索引

ALTER TABLE `USER` ADD UNIQUE INDEX (`MOBILE`);

重新打开查询分析器

 

会话A会话B

BEGIN;

SELECT * FROM `USER` WHERE MOBILE = '13121771001' FOR UPDATE

BEGIN;

SELECT * FROM `USER` WHERE MOBILE = '13121771002' FOR UPDATE

173924_HoZW_1048116.png173847_vs4w_1048116.png

结论：使用唯一索引和主键是相同效果。

 

 

四、没有唯一行对INSERT的影响

查询不到唯一行，会导致表锁

会话A会话B

BEGIN;

SELECT * FROM `USER` WHERE ID = 1 FOR UPDATE;

BEGIN;

INSERT INTO `USER` VALUES (1, '13121771000', 'test1000');

174024_0a0X_1048116.png174336_v7ex_1048116.png

结论：查询不到数据行的情况下，导致insert会失败，这是因为MySQL无法将其视为行级锁，会锁住整表

 

 

五、存在唯一行对INSERT的影响

会话A会话B

BEGIN;

SELECT * FROM `USER` WHERE ID = 222 FOR UPDATE;

BEGIN;

INSERT INTO `USER` VALUES (1, '13121771000', 'test1000');

173924_HoZW_1048116.png174501_zg3a_1048116.png

 结论：行锁的情况下，新增数据行不受影响

 

 

六、没有唯一行对Update的影响

where条件无索引，所有行被锁

 

会话A会话B

修改该行数据：

102647_ndih_1048116.png

 

查询其他数据行：

BEGIN;

SELECT * FROM `USER` WHERE ID = 223 FOR UPDATE;

 

UPDATE `USER` SET `NAME` = 'test_*' WHERE `NAME` = 'test1001';103116_EmXe_1048116.png

 

where字段是唯一索引或者主键只会锁住一行数据

 

会话A会话B

BEGIN;

UPDATE `USER` SET  `NAME` = 'demo1' WHERE ID = 222;

BEGIN;

SELECT * FROM `USER` WHERE ID = 223 FOR UPDATE;

133425_tLYj_1048116.png

133525_aswi_1048116.png

 

在RR级别下InnoDB数据存储引擎行锁的算法默认采用 NEXT-Key Lock，而在RC级别下使用的是 Record Lock，举例说明：

 

会话A会话B
155704_yM2s_1048116.png155704_yM2s_1048116.png

161151_SgfQ_1048116.png

161151_SgfQ_1048116.png

161232_ZGaQ_1048116.png

事务未结束，该阶段没有提交

160245_64iv_1048116.png

此时会话B，由于RR事务隔离级别的特性，采用Next-Key Lock（前面介绍了，该算法是 Gap Lock + Record Lock） 算法，会锁定一个区间

 

 

 

会话A会话B
163227_AFJb_1048116.png163227_AFJb_1048116.png
163412_UUNp_1048116.png163412_UUNp_1048116.png

163657_VG3k_1048116.png

 

事务未结束，该阶段没有提交

163727_43t8_1048116.png

 

可以正常插入新记录，证明此时RC级别默认采用的是行锁机制

 

COMMIT;

164624_AYzq_1048116.png

 

该操作论证了，RC事务隔离级别下，该事务是中出现不可重复读的现象

 

 

参考资料：

排它锁 http://baike.baidu.com/link?url=_qX1F30WiR0pLBcXyuLOW4rosho8sZP50aGwKkwoHVRDy1wDH6kTlzR5ov4gT5HbIAb3BS7q2LyjbBYrqHK2-K

共享锁 http://baike.baidu.com/link?url=iXk1XXZUbukRI9TkY_frxzjLfI4U7ZX5Oc_ThdLz79WiRrzwa1mYyt2Wdn9naObSy_z-mnGXn1-jhxvDhjLLiq

《MySQL技术内幕InnoDB存储引擎第2版》

 

转载于:https://my.oschina.net/u/1048116/blog/668252

chuizheng9029
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring jpa 行级锁的实现
fengyuxue11011的专栏
07-24 2万+
最近要做一个新项目，需要借助mysql的行级锁机制，又由于是第一次使用jpa去实现行级锁，所以遇到了一丢丢问题，昨天晚上用了1个多小时解决了。。分享下。。 -------------------------------------------------------------------------------------------------------------------------
spring配置事务，是否可以实现行级锁（for update）
viei
12-22 1560
spring配置事务，是否可以实现行级锁（for update） 通过配置传播行为，隔离级别应是不行的把？ 我现在的做法是在dao里面直接用悲观锁来弄的 觉的这样太好，如果这个查询方法有时候需要实现行级锁有时候不需要我是否还要写两个不同的方法 比如我每次 select * from table where id=1 取一条商品信息，然后扣款，配送，最后把这个条记录修改为已卖...
spring 事务传播行为、隔离级别、行级锁
XiaoY的专栏
07-08 473
spring 事务传播行为 传播行为 含义 PROPAGATION_REQUIRED 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务 PROPAGATION_SUPPORTS 表示当前方法不需要事务上下文。如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。 PROPAGATION_MANDATORY 表示该方法必须在事务中运行。如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。 PROPA
学习InnoDB的锁机制原理解析
默默的笔记
06-23 521
一、查看数据库默认隔离级别： select @@tx_isolation; 修改数据库默认隔离级别： set tx_isolation = "REPEATABLE-READ" 二、InnoDB的锁机制原理解析 InnoDB行锁，就是给索引上的索引项加锁，如果操作的字段没有索引，则直接使用表锁。 2.1 共享锁 S锁 读锁 ，上锁数据其他事务不能修改，可读取 2.2 排他锁 X锁 写锁 ， 2.3 意向共享锁 IS 获得操作表的共享锁之前，需要先获取意向共享锁。 可以优化锁之间的性能。快速
spring 操作 oracle 行级锁
java
03-26 6261
在使用sping 数据库使用oracle 时，想要更新某一条记录时，其他的线程不可操作此条记录，可以使用select * from tableName where id=? for update; 这样就可以把这条符合条件的记录上锁，行级锁。什么时候解锁呢，这个需要 手动提交事务后 就解锁了。spring 提供了手动提交事务的操作。 @Autowired TransactionTemplat
spring-transaction-manager:Spring事务管理实现原理及MySQL InnoBD引擎行锁概述---配套代码
04-28
本篇将深入探讨Spring事务管理的实现原理以及MySQL InnoDB引擎的行锁概念。 Spring事务管理是通过其核心接口`PlatformTransactionManager`来实现的，它定义了事务开始、提交、回滚和查询事务状态的方法。Spring提供...
mysql行级锁原理_mysql行级锁实现原理是什么
weixin_42361112的博客
02-02 239
mysql行级锁实现原理：1、InnoDB行锁是通过给索引项加锁来实现的，这一点mysql和oracle不同；2、InnoDB这种行级锁决定，只有通过索引条件来检索数据，才能使用行级锁，否则，直接使用表级锁。mysql行级锁实现原理：锁是在执行多线程时用于强行限定资源访问的同步机制，数据库锁根据锁的粒度可分为行级锁，表级锁和页级锁行级锁行级锁是mysql中粒度最细的一种锁机制，表示只对当前所操作的...
Spring事务处理的实现--基于底层API
WARGON的博客
07-31 438
引入相关的包是必须的。Spring四个核心包、Sping-jdbc包、mysql-connector-javabao 配置文件：引入数据库的Bean：DriverManagerDataSource并进行驱动、url等的配置。引入JDBCTemplate的Bean：JDBCTemplate并配置其datasource属性。要使用Spring的事务管理器，引入：DataSourceTransacti...
SpringBoot系列之数据库初始化-datasource配置方式
最新发布
小灰灰blog的专栏
12-28 2357
如何实现在项目启动之后执行相应的sql，实现数据库表的初始化？ 本文将作为初始化方式的第一篇：基于SpringBoot的配置方式实现的数据初始化
正确理解Spring事务和数据库事务和锁
热门推荐
codingtu的博客
09-20 5万+
Lock wait timeout exceeded; try restarting transaction解决方案
spring事务与锁汇总。
xiaofancn的专栏
01-22 1042
  spring事务传播   PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择，默认。 PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。 PROPAGATION_REQUIRES_N...
事务超时
08-29 1万+
事务超时       本文概览：介绍了超时有关的概念：@Transaction的timeout、mybatis的timeout、mysql的innodb_lock_wait_timeout。 1 问题 1.1 背景 在一个事务中完成解析一个大文件，分批存入到数据库。遇到问题，执行时间比较长，就讨论了事务超时的问题，担心执行时间太长，事务超时自动回滚了。 为了考虑这个问题，需要考虑如下...
简单实现spring boot+mysql行锁
非我非非我的博客
12-08 5546
修改sql：只需要在select sql尾部添加for update。 启用事务，并为service添加注解：@Transactional 随便写两个测试的controller test1和test2，test1中对数据做两次查询，中间通过Thread.sleep(10000);休眠10秒。在test2中对test1中查询的那条记录进行update，控制台可以看下输出。顺序是test1完全执行...
SpringBoot-行锁
BtWangZhi的博客
11-15 4694
在代码中看到同事写的SQL代码中有FOR UPDATE，百度了一下，说是MYSQL行锁，自己写个demo验证一下。 参考博客：https://blog.csdn.net/u011957758/article/details/75212222 场景：锁住用户的信息，在这期间不允许其他线程修改该用户信息， &lt;select id="lockUserInfoById" parameterTy...
分布式锁和spring事务管理
weixin_34082789的博客
08-28 917
最近开发一个小程序遇到一个需求需要实现分布式事务管理 业务需求 用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记...
深入理解spring事务底层实现原理
xiaobu201314的博客
11-04 2万+
事务 相信大家都在ATM机取过钱，但是是否有人考虑过它的流程是怎样的呢？ 我们都知道，假如我们取300块钱，那么当这三百块钱从ATM机出来时，我们的账户相应的会减少300。这两个过程一定是要同时成功才算成功的。否则就会出现账户少了300.但是钱没出来，对于我们来说，我们损失了300.而如果钱出来了但是账户钱没扣掉的话，银行就会损失300.这两种情况都是不可取的。所以就需要保证要么大家一起成功，有一...
关于MySQL的lock wait timeout exceeded解决方案
weixin_34166472的博客
06-18 1万+
关于MySQL出现lock wait timeout exceeded; try restarting transaction 的解决方案。 一、问题抛出 在做查询语句时，MySQL 抛出了这样的异常： MySQL server error report:Array ( [0] => Array ( ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值