我要评论一、场景分析
假设有这么一张表：
create table pms_sec_kill_sku
(
id int auto_increment comment '主键id'
primary key,
spec_detail varchar(50) not null comment '规格描述',
purchase_price decimal(10, 2) not null comment '采购价格',
sale_price decimal(10, 2) not null comment '销售价格',
origin_stock int unsigned default '0' not null comment '初始库存',
sold_stock int unsigned default '0' not null comment '已售库存',
stock int unsigned default '0' not null comment '实时库存',
occupy_stock int unsigned default '0' not null comment '订单占用库存',
version int default 0 not null comment '乐观锁版本号',
created_time datetime not null comment '创建时间',
updated_time datetime not null comment '更新时间'
)
comment '促销管理服务-秒杀商品sku';一张简单的秒杀商品sku表。使用 version 字段做乐观锁。使用 unsigned 关键字，限制 int 类型非负，防止库存超卖。
使用 mybatisplus 来配置乐观锁：
import com.baomidou.mybatisplus.annotation.dbtype;
import com.baomidou.mybatisplus.extension.plugins.mybatisplusinterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.optimisticlockerinnerinterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.paginationinnerinterceptor;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.transaction.annotation.enabletransactionmanagement;
@enabletransactionmanagement
@configuration
public class mybatisplusconfig {
@bean
public mybatisplusinterceptor mybatisplusinterceptor() {
mybatisplusinterceptor interceptor = new mybatisplusinterceptor();
// 分页插件
interceptor.addinnerinterceptor(new paginationinnerinterceptor(dbtype.mysql));
// 乐观锁插件
interceptor.addinnerinterceptor(new optimisticlockerinnerinterceptor());
return interceptor;
}
@bean
public defaultdbfieldhandler defaultdbfieldhandler() {
defaultdbfieldhandler defaultdbfieldhandler = new defaultdbfieldhandler();
return defaultdbfieldhandler;
}
}@data
@tablename("pms_sec_kill_sku")
@apimodel(value = "pmsseckillsku对象", description = "促销管理-秒杀商品sku")
public class pmsseckillsku implements serializable {
private static final long serialversionuid = 1l;
// @version 注解不能遗漏
@version
@apimodelproperty("乐观锁版本号")
private integer version;
// other properties ......
}现在有这么一个支付回调接口：
/**
* 促销管理-秒杀商品sku 服务实现类
* @since 2025-02-26 14:21:42
*/
@service
public class pmsseckillskuserviceimpl extends serviceimpl<pmsseckillskumapper, pmsseckillsku> implements pmsseckillskuservice {
// 最大重试次数
private static final int max_retries = 3;
/**
* 订单支付成功回调
* 假设每次只能秒杀一个数量的sku
*/
@override
@transactional(rollbackfor = exception.class)
public void paysuccallback(integer skuid) {
// 持久化库存
int count = 0, retries = 0;
while (count == 0 && retries < max_retries) {
pmsseckillskuvo pmsskuvo = this.basemapper.finddetailbyid(skuid);
pmsseckillsku wt = new pmsseckillsku();
wt.setid(pmsskuvo.getid());
wt.setversion(pmsskuvo.getversion());
// 占用库存减1
wt.setoccupystock( pmsskuvo.getoccupystock()-1 );
// 已售库存加1
wt.setsoldstock( pmsskuvo.getsoldstock()+1 );
// 实时库存减1
wt.setstock( pmsskuvo.getstock()-1 );
count = this.basemapper.updatebyid(wt);
retries++;
if (count == 0) {
try {
thread.sleep(100);
} catch (interruptedexception e) {
throw new businessexception(e.getmessage());
}
}
}
if (count == 0) {
throw new businessexception("请刷新后重新取消!");
}
}
}该方法的目的，是为了进行库存更新，当乐观锁版本号有冲突时，对方法进行休眠重试。
该方法在测试环境还能正常跑，到了生产环境，却频繁报 "请刷新后重新取消!"
仔细分析后发现，测试环境的mysql数据库全局隔离级别是，read-committed（读已提交）。而生产环境是 repeatable_read（可重复读）。
show global variables like 'transaction_isolation';
- 在读已提交隔离级别下，该方法每次重试，都能读取到别的事务提交的最新的 version，相当于拿到乐观锁。
- 在可重复读隔离级别下，因为有 mvcc 多版本并发控制，该方法每次重试，读取到的都是同一个结果，相当于一直拿不到乐观锁。所以多次循环之后，count 还是等于 0，程序抛出异常。
二、简单验证
假设现在表里面有这么一条记录：
insert into `pms_sec_kill_sku` (`id`, `spec_detail`, `purchase_price`, `sale_price`, `origin_stock`, `sold_stock`, `stock`, `occupy_stock`, `version`, `created_time`, `updated_time`) values (1, '尺码:m1', 100.00, 1.00, 2, 0, 2, 2, 2, '2025-02-26 15:51:22', '2025-02-26 15:51:24');
2.1、可重复读
修改服务程序：
- 增加会话的隔离级别为 isolation = isolation.repeatable_read 可以重复读。
- 增加记录日志。
- 在方法更新前阻塞当前线程，模拟另一个事务先提交。
@api(value = "促销管理-秒杀商品sku", tags = {"促销管理-秒杀商品sku接口"})
@restcontroller
@requiredargsconstructor
@requestmapping("pmsseckillsku")
public class pmsseckillskucontroller {
private final pmsseckillskuservice pmsseckillskuservice;
@apioperation(value = "支付成功", notes = "支付成功")
@postmapping("/pay")
public r<void> pay(integer id) {
pmsseckillskuservice.paysuccallback(id);
return r.success();
}
}
访问接口：
### post http://localhost:5910/pmsseckillsku/pay?id=1 content-type: application/json token: 123
在第0次查询的时候，执行更新：
update `pms_sec_kill_sku` set sold_stock = sold_stock + 1, stock = stock - 1, occupy_stock = occupy_stock - 1, version = version + 1 where id = 1;
可以看到，三次查询，返回结果都是一样的：
数据库的版本号只有3：
2.2、读已提交
修改会话的隔离级别为 isolation = isolation.read_committed 读已提交。
恢复数据：
访问接口：
### post http://localhost:5910/pmsseckillsku/pay?id=1 content-type: application/json token: 123
在第0次查询的时候，执行更新：
update `pms_sec_kill_sku` set sold_stock = sold_stock + 1, stock = stock - 1, occupy_stock = occupy_stock - 1, version = version + 1 where id = 1;
可以看到，第0次查询的时候，version=2；执行完 sql语句，第1次查询的时候，version=3；拿到了乐观锁，更新成功。
三、最佳实践
可以看到，使用 thread.sleep 配合循环来进行获取乐观锁的重试，存在一些问题：
- 依赖事务隔离级别的正确设置。
- 休眠的时间不好把控。
- 代码复用性差。
spring retry 提供了一种更优雅的方式，来进行乐观锁的重试。
恢复数据：
3.1、配置重试模板
import org.springframework.retry.policy.simpleretrypolicy;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.retry.annotation.enableretry;
import org.springframework.retry.backoff.fixedbackoffpolicy;
import org.springframework.retry.support.retrytemplate;
@configuration
@enableretry
public class retryconfig {
@bean
public retrytemplate retrytemplate() {
retrytemplate retrytemplate = new retrytemplate();
// 设置重试策略，这里设置最大重试次数为3次
simpleretrypolicy retrypolicy = new simpleretrypolicy(3);
retrytemplate.setretrypolicy(retrypolicy);
// 设置重试间隔时间，这里设置为固定的500毫秒
// 可以根据系统的并发度，来设置
// 并发度高，设置长一点，并发度低，设置短一点
fixedbackoffpolicy backoffpolicy = new fixedbackoffpolicy();
backoffpolicy.setbackoffperiod(500);
retrytemplate.setbackoffpolicy(backoffpolicy);
return retrytemplate;
}
}3.2、使用 spring 的@retryable注解
@override
@retryable(value = optimisticlockingfailureexception.class)
@transactional(rollbackfor = exception.class,
isolation = isolation.repeatable_read)
public void paysucretry(integer skuid) {
pmsseckillskuvo pmsskuvo = this.basemapper.finddetailbyid(skuid);
log.info("===============查询结果为{}", pmsskuvo);
pmsseckillsku wt = new pmsseckillsku();
wt.setid(pmsskuvo.getid());
wt.setversion(pmsskuvo.getversion());
// 占用库存减1
wt.setoccupystock( pmsskuvo.getoccupystock()-1 );
// 已售库存加1
wt.setsoldstock( pmsskuvo.getsoldstock()+1 );
// 实时库存减1
wt.setstock( pmsskuvo.getstock()-1 );
try {
thread.sleep(10000);
} catch (interruptedexception e) {
throw new businessexception(e.getmessage());
}
int count = this.basemapper.updatebyid(wt);
if (count == 0) {
throw new optimisticlockingfailureexception("乐观锁冲突");
}
}当乐观锁冲突的时候，抛出异常， optimisticlockingfailureexception。
这里特意设置事务隔离级别为 repeatable_read
3.3、测试
访问接口：
@api(value = "促销管理-秒杀商品sku", tags = {"促销管理-秒杀商品sku接口"})
@restcontroller
@requiredargsconstructor
@requestmapping("pmsseckillsku")
public class pmsseckillskucontroller {
private final pmsseckillskuservice pmsseckillskuservice;
@apioperation(value = "可重试", notes = "可重试")
@postmapping("/retry")
public r<void> retry(integer id) {
pmsseckillskuservice.paysucretry(id);
return r.success();
}
}### post http://localhost:5910/pmsseckillsku/retry?id=1 content-type: application/json token: 123
在第0次查询的时候，执行更新：
update `pms_sec_kill_sku` set sold_stock = sold_stock + 1, stock = stock - 1, occupy_stock = occupy_stock - 1, version = version + 1 where id = 1;
可以看到，在第二次查询的时候，就获取到锁，并成功执行更新。
到此这篇关于spring retry 实现乐观锁重试的文章就介绍到这了,更多相关spring retry 乐观锁重试内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论