秒杀相关问题解决

秒杀

超卖问题

如下,我们先来复现问题,抢购秒杀券的代码逻辑也是很简单,
在这里插入图片描述
先判断优惠券是否开始了,是的化,判断库存是否充足,如果是的化,扣减库存,最后创建订单

如下是代码

@Override
@Transactional
public Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = seckillVoucher.getById(voucherId);if(voucher == null) {return Result.fail("优惠券不存在");}//2.判断秒杀是否开始if(voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("秒杀活动还没开始!");}//3.判断秒杀是否结束if(voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("秒杀活动已经结束了!");}//4.判断库存是否充足if(voucher.getStock() < 1) {return Result.fail("库存不足!");}//5.扣减库存boolean isSuccess = seckillVoucher.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).update();//6.判断是否成功if(!isSuccess) {return Result.fail("扣减库存失败!");}//7.创建订单VoucherOrder voucherOrder = new VoucherOrder();//7.1订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//7.2用户idLong userId = UserHolder.getUser().getId();voucherOrder.setUserId(userId);//7.3代金券idvoucherOrder.setVoucherId(voucherId);//7.4保存到voucher_order表中save(voucherOrder);//8.返回订单idreturn Result.ok(orderId);
}

问题出现如下代码
在这里插入图片描述
我们判断是否充足的时候,有可能很多线程进来刚好都通过了,就会有问题

测试

在这里插入图片描述

设置jmeter
在这里插入图片描述

这里是加上token头,因为我的系统写了token头,才能通过,你要是没有的化,就不用

测试结果
在这里插入图片描述
如此就是超卖了

乐观锁 & 悲观锁

理解乐观锁 & 悲观锁

乐观锁有可能你还不是很懂,但是你一定要知道这个,乐观锁,实际上没有加锁,主打的就是一个乐观,如果发现没有问题,就不上锁,如果有问题,就通过特殊的手段保证线程的安全,这里的特殊的手段一般来说,就是类似于cas这样的,使用一个标识来判断是否有线程安全问题

悲观锁就很好理解了,就是平常我们加的粒度很大的锁,例如synchronized

乐观锁的思想

乐观锁的实操都是一个统一的思想,就是cas,比较 + 交换
比较的是什么,得到的旧值和我们再一次得到的值(理解为新值) 判断是否是一致的,如果不是一致的,那么就代表着有线程安全问题

我们再来理解一下这里的比较的意思,为什么要比较我们得到的值,举个例子

一开始我们拿到 stock = 100
然后过了几s,我们再去获取stock,发现stock = 98
是不是就说明这里的stock被人用过了,那么就有线程安全问题!此时我们就退出,或者人为再去加锁,都是可以的,一般来说,乐观锁不会直接加锁

我们再来想一个问题,为什么要有乐观锁???
我直接加锁不好吗?? 为的是两个字性能!!!

我们一旦加了大粒度的锁,就会消耗性能,在那等吗,当然消耗了,所以就有了乐观锁的存在,它实际上是没有锁的,所以性能当然高!!!

乐观锁的缺点

那难道说,乐观锁,就那么好,没什么缺点? 肯定是有的, 会有完成率的问题
完成率不高,甚至于说,本来200 人抢100张优惠券的问题,但是由于设置的乐观锁, 再高并发下,很容易很多的线程都没有抢到,这种问题,在我这里也出现了, 解决办法就是改变比较条件就行,实例请看下面

乐观锁解决超卖

在这里插入图片描述
想我这里就是,简单的cas,判断是否是刚刚的库存

乐观锁完成率不高问题

在这里插入图片描述
我们这里更改了条件,只要库存 > 0的化,就可以成功!

这里为什么可以保证原子性,我觉得需要特别说明一下
我们请求打到数据库的时候那个时间点有条件 stock > 0
因为有事务的原因,mysql这里的写操作是线程安全的,所以这里不会有问题

一人一单问题

一人一单问题,也是可能会有线程安全问题
我们先来看流程图
在这里插入图片描述
再超卖问题解决之下,去判断是否已经下过一单了,是的化,就不去下单

代码如下

    @Overridepublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = seckillVoucher.getById(voucherId);if (voucher == null) {return Result.fail("优惠券不存在");}//2.判断秒杀是否开始if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("秒杀活动还没开始!");}//3.判断秒杀是否结束if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("秒杀活动已经结束了!");}//4.判断库存是否充足if (voucher.getStock() < 1) {return Result.fail("库存不足!");}Long userId = UserHolder.getUser().getId();//5.一人一单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();if(count > 0) {return Result.fail("你已经买过了");}//6.扣减库存boolean isSuccess = seckillVoucher.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock",0).update();//7.判断是否成功if (!isSuccess) {return Result.fail("扣减库存失败!");}//8.创建订单VoucherOrder voucherOrder = new VoucherOrder();//8.1订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//8.2用户idvoucherOrder.setUserId(userId);//8.3代金券idvoucherOrder.setVoucherId(voucherId);//8.4保存到voucher_order表中save(voucherOrder);//9.返回订单idreturn Result.ok(orderId);}

问题处在这
在这里插入图片描述如果高并发的情况下,就有可能会有问题

复现线程安全问题

jmeter设置: 和超卖问题的复现jmeter设置是一致的

在这里插入图片描述

原先订单数100
在这里插入图片描述

抢购17号优惠券,正常来说,一个用户只能抢1张

测试结果
在这里插入图片描述

下了10单
在这里插入图片描述

这里就是一人一单出了线程安全问题!

加锁解决

    @Autowiredprivate SeckillVoucherServiceImpl seckillVoucher;@Resourceprivate RedisIdWorker redisIdWorker;@Overridepublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = seckillVoucher.getById(voucherId);if (voucher == null) {return Result.fail("优惠券不存在");}//2.判断秒杀是否开始if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("秒杀活动还没开始!");}//3.判断秒杀是否结束if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("秒杀活动已经结束了!");}//4.判断库存是否充足if (voucher.getStock() < 1) {return Result.fail("库存不足!");}return createVoucherOrder(voucherId);}    @Transactionalpublic synchronized Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();//5.一人一单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();System.out.println("此时count为" + count);if (count > 0) {return Result.fail("用户已经购买过一次");}//6.扣减库存boolean isSuccess = seckillVoucher.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();//7.判断是否成功if (!isSuccess) {return Result.fail("扣减库存失败!");}//8.创建订单VoucherOrder voucherOrder = new VoucherOrder();//8.1订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//8.2用户idvoucherOrder.setUserId(userId);//8.3代金券idvoucherOrder.setVoucherId(voucherId);//8.4保存到voucher_order表中save(voucherOrder);//9.返回订单idreturn Result.ok(orderId);}

再整个方法上加锁,这样确实是万无一失

测试
在这里插入图片描述

结果是正确的

优化加锁

如果直接再方法上加锁的化,那么锁的是类对象,也就是这里的service类对象,那么单用户情况下就没问题,但是在多用户情况下就会有问题,因为这里的锁是service类,那么相当于锁的是全部人,也就是说,别的用户还得等你抢完了才能枪,所以这里的锁的粒度有问题,应该锁的是对应的用户而不是所有用户!!!

    @Transactionalpublic Result createVoucherOrder(Long voucherId) {//只锁住相同用户,所以这里用userIdLong userId = UserHolder.getUser().getId();//这里是更细粒度的锁,这里不能直接用Long userId来锁,因为有可能是同一个对象,jvm知识//所以这里用字符串对象,但是Long的toString()里边也是new String(),所以这里要intern()//避免相同的用户却有着不同的锁,再字符串池里边找到我们那个唯一的用户stringsynchronized (userId.toString().intern()) {//5.一人一单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();System.out.println("此时count为" + count);if (count > 0) {return Result.fail("用户已经购买过一次");}//6.扣减库存boolean isSuccess = seckillVoucher.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();//7.判断是否成功if (!isSuccess) {return Result.fail("扣减库存失败!");}//8.创建订单VoucherOrder voucherOrder = new VoucherOrder();//8.1订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//8.2用户idvoucherOrder.setUserId(userId);//8.3代金券idvoucherOrder.setVoucherId(voucherId);//8.4保存到voucher_order表中save(voucherOrder);//9.返回订单idreturn Result.ok(orderId);}}

这样子锁的才是用户,多人抢的化,就不会相互干涉

事务失效

提到这个我不得不说,这个问题比较难理解,这里的问题相关springboot中的事务

我们来看这里的代码

在这里插入图片描述

在这个方法上我们加上了事务 @Transactional 也就是springboot事务处理
,这个注解默认什么都不写的情况下,事务的隔离级别是数据库的隔离级别,而我这里的数据库是mysql,也就是读已提交
什么是读已提交,也就是说,只能读到已经提交的事务,那些没有提交的事务,别的事务是看不到的

这个隔离级别就是为了解决脏读 + 脏写的问题来着,但是反而在这里会出现问题

我门来看这里的流程

事务开始
上锁
业务代码
释放锁
事务结束

因为这里的锁是嵌套在这个方法里边的,并不是方法上的,所以说,我们释放锁的时候,事务不一定结束!! 换种方法说,就是事务没有提交!

这个问题很关键! 你事务没有提交,意思是别人根本读不到你这里的已经下了单的order,并且你还已经释放锁了,所以别的线程进来,就可以又来下单

所以总的来说,你看这个代码,这个问题的出现就是那么一瞬间的事,但是还是有可能会出现问题的

我们总结一下,为什么会出现这个问题,就是因为释放锁和事务的提交不同步,先释放锁了,才去提交事务,这样别人就有可乘之机,所以我们的解决方法就是先去提交事务,再去释放锁

那么我门的锁,就应该锁的是这整个方法了

代码

    @Overridepublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = seckillVoucher.getById(voucherId);if (voucher == null) {return Result.fail("优惠券不存在");}//2.判断秒杀是否开始if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("秒杀活动还没开始!");}//3.判断秒杀是否结束if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("秒杀活动已经结束了!");}//4.判断库存是否充足if (voucher.getStock() < 1) {return Result.fail("库存不足!");}Long userId = UserHolder.getUser().getId();synchronized (userId.toString().intern()) {return createVoucherOrder(voucherId);}}@Transactionalpublic Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();//5.一人一单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();System.out.println("此时count为" + count);if (count > 0) {return Result.fail("用户已经购买过一次");}//6.扣减库存boolean isSuccess = seckillVoucher.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();//7.判断是否成功if (!isSuccess) {return Result.fail("扣减库存失败!");}//8.创建订单VoucherOrder voucherOrder = new VoucherOrder();//8.1订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//8.2用户idvoucherOrder.setUserId(userId);//8.3代金券idvoucherOrder.setVoucherId(voucherId);//8.4保存到voucher_order表中save(voucherOrder);//9.返回订单idreturn Result.ok(orderId);}

这里还有一个问题,就是这里没有调用事务

这里的 return createVoucherOrder(voucherId);
实际上的写法是这样
return this.createVoucherOrder(voucherId);

是用这个类的对象来调用的,但是由于spring底层是通过aop来实现事务管理的,我们要用代理对象才能发起一个事务,不然还是会有问题!!!

代码

    @Overridepublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = seckillVoucher.getById(voucherId);if (voucher == null) {return Result.fail("优惠券不存在");}//2.判断秒杀是否开始if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {return Result.fail("秒杀活动还没开始!");}//3.判断秒杀是否结束if (voucher.getEndTime().isBefore(LocalDateTime.now())) {return Result.fail("秒杀活动已经结束了!");}//4.判断库存是否充足if (voucher.getStock() < 1) {return Result.fail("库存不足!");}Long userId = UserHolder.getUser().getId();synchronized (userId.toString().intern()) {//获取代理对象IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);}}@Transactionalpublic Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();//5.一人一单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();System.out.println("此时count为" + count);if (count > 0) {return Result.fail("用户已经购买过一次");}//6.扣减库存boolean isSuccess = seckillVoucher.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();//7.判断是否成功if (!isSuccess) {return Result.fail("扣减库存失败!");}//8.创建订单VoucherOrder voucherOrder = new VoucherOrder();//8.1订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//8.2用户idvoucherOrder.setUserId(userId);//8.3代金券idvoucherOrder.setVoucherId(voucherId);//8.4保存到voucher_order表中save(voucherOrder);//9.返回订单idreturn Result.ok(orderId);}

要设置这个还得加一个依赖

 <dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId></dependency>

在主启动类上

@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.hmdp.mapper")
@SpringBootApplication
public class HmDianPingApplication {public static void main(String[] args) {SpringApplication.run(HmDianPingApplication.class, args);}}

一人一单(集群)

搭建集群

我这里搭建的集群是jvm的集群,在idea中的jvm集群

idea复用一个8082接口的应用程序

按alt + 8 可以跳出service

然后复制一份应用程序
在这里插入图片描述
更改端口

nginx配置

打开nginx conf文件下的nginx.conf

这里需要修改就是,下面的把注释打开,并且把上面的8081固定的关闭

这里的意思就是,请求8080,转到http://backend

然后nginx自动会轮询这两个server,一个是8081,一个是8082

在这里插入图片描述


worker_processes  1;events {worker_connections  1024;
}http {include       mime.types;default_type  application/json;sendfile        on;keepalive_timeout  65;server {listen       8080;server_name  localhost;# 指定前端项目所在的位置location / {root   html/hmdp;index  index.html index.htm;}error_page   500 502 503 504  /50x.html;location = /50x.html {root   html;}location /api {  default_type  application/json;#internal;  keepalive_timeout   30s;  keepalive_requests  1000;  #支持keep-alive  proxy_http_version 1.1;  rewrite /api(/.*) $1 break;  proxy_pass_request_headers on;#more_clear_input_headers Accept-Encoding;  proxy_next_upstream error timeout;  
#             proxy_pass http://127.0.0.1:8081;proxy_pass http://backend;}}upstream backend {server 127.0.0.1:8081 max_fails=5 fail_timeout=10s weight=1;server 127.0.0.1:8082 max_fails=5 fail_timeout=10s weight=1;}  
}

更改完之后,要在cmd上重新启动一下

nginx.exe -s reload

在这里插入图片描述

问题出现

将两个应用程序以调试的模式打开

在这里打个断点
在这里插入图片描述

apifox的设置

在这里插入图片描述

第一个用户的配置

第二个用户是一样的

也就是说是同一用户,不过是不同的集群

测试

原先数据库的数据
首先是优惠券表
在这里插入图片描述
然后是优惠券订单表

是空的

2个接口都发起请求

发现两个应用程序都进去了

在这里插入图片描述
测试发现两个请求都进来了,这和我们的一人一单有问题,他这里会生成两个订单

如下
在这里插入图片描述

正常来说,我这里设了锁,应该是只能下一单,但是这里再集群情况下,下了两单,所以发生了线程安全问题!

发生问题的有原因

我门要先搞清楚集群的问题,如果是两个集群的化,那么代表的是两个jvm,相当于两个不同的进程,而我们之前那样子加锁,它的范围是jvm的内部,所以这里加锁无效,从这,就引申出分布式锁的概念

简单总结一下,就是没锁上,需要更大范围的锁!

分布式锁

分布式锁有三种实现
- 在这里插入图片描述
对于mysql来说,它的互斥锁的实现就是通过事务来实现的,我们再写的时候,会再写上加锁,但我认为这个还是很难的,如果要实现的哈

用redis来实现,比较好实现,就是用setnx,来实现互斥锁

zookeeper 我还不懂,掠过

我这里的获取锁 + 释放锁,已经写好了
代码如下

    /*** 尝试获取锁* @param pattern key* @param value 值* @param <T>* @return*/public <T> boolean tryLock(String pattern,T value){Boolean flag = redisTemplate.opsForValue().setIfAbsent(pattern, value, 2, TimeUnit.MINUTES);return BooleanUtil.isTrue(flag);}/*** 解锁* @param pattern*/public void unlock(String pattern) {//删除锁redisTemplate.delete(pattern);}

给我封装到了我的redis 操作的工具类里边了

问题解决

我们先来看,解决问题的流程,做好一个心里预期
在这里插入图片描述
这个流程还算简洁的

我们直接看解决的代码

@Service
@Slf4j
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService seckillVoucherService;@Autowiredprivate RedisIdWorker redisIdWorker;@Autowiredprivate RedisCache redisCache;/*** 抢购秒杀券** @param voucherId* @return*/@Override
//    @Transactionalpublic Long seckillVoucher(Long voucherId) {SeckillVoucher voucher = seckillVoucherService.getById(voucherId);log.info("当前库存为 : {}", voucher.getStock());if (Objects.isNull(voucher)) {throw new BaseException("优惠券不存在!");}LocalDateTime nowTime = LocalDateTime.now();//优惠券时间是否开始了if (voucher.getBeginTime().isAfter(nowTime)) {throw new BaseException("优惠券时间还没开始!");}//是否结束了if (voucher.getEndTime().isBefore(nowTime)) {throw new BaseException("优惠券时间已经结束了");}//判断库存是否充足if (voucher.getStock() < 1) {throw new BaseException("库存不足!");}Long userId = UserHolder.getUser().getId();//锁的value是当前线程idlong threadId = Thread.currentThread().getId();boolean isSuccess = redisCache.tryLock(RedisConstants.LOCK_SECKILL_VOUCHER_KEY, threadId + "", RedisConstants.LOCK_SECKILL_VOUCHER_TTL, TimeUnit.SECONDS);if (!isSuccess) {throw new BaseException("用户已经买过了!");}try {IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);} finally {String lockId = redisCache.getObject(RedisConstants.LOCK_SECKILL_VOUCHER_KEY);//判断是否是一样的锁if (StrUtil.isNotBlank(lockId) && lockId.equals(Thread.currentThread().getId() + "")) {redisCache.unlock(RedisConstants.LOCK_SECKILL_VOUCHER_KEY);}}}@Transactionalpublic synchronized Long createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();//一人一单问题LambdaQueryWrapper<VoucherOrder> orderWrapper = new LambdaQueryWrapper<>();orderWrapper.eq(VoucherOrder::getUserId, UserHolder.getUser().getId()).eq(VoucherOrder::getVoucherId, voucherId);int count = count(orderWrapper);if (count > 0) {throw new BaseException("你已经买过了!");}//扣减库存boolean isSuccess = seckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();if (!isSuccess) {throw new BaseException("扣减库存失败!");}long orderId = redisIdWorker.nextId("order");VoucherOrder voucherOrder = VoucherOrder.builder().id(orderId).userId(userId).voucherId(voucherId).build();save(voucherOrder);return orderId;}
}

改动的代码如下
在这里插入图片描述

代码很简洁,就是加一个锁,只不过这个锁是再redis中,如果获取失败,那就说明,有人再抢,有人再抢的化,就直接爆错退出,这样才符合一人一单

测试

这里的测试我就不写了,因为没什么意思,最后结果就是一人一单

小问题

这里的小问题,就是如果按照我门上面这种写法,锁住是所有的用户,而我们加锁是对各个用户加锁,做到一人一单,用户之间应该是隔离的才对,所以这里应该再锁上加上用户的标记,这样别的用户就可以进来了,去枪单

这里实现还是很简单的,就是写rediskey的时候加上 userId

在这里插入图片描述

分布式锁误删问题

因为我们加了redis分布式锁,并且这里的分布式锁,是有过期时间的,所以就会延申出这个问题

为什么要设置过期时间

我们首先先声明一点,为什么必须要加过期时间,咱们这个问题的出现就是由于这个过期时间的问题,为什么我们不能做成永久key呢?

这个问题的答案,就是如果我们做成永久key,一个线程拿到了锁,然后突然发生异常了,或者业务阻塞了, 那么就相当于说,锁释放不了了,那么程序的性能就会大大降低,甚至于我们有可能得人为去干预这个问题

虽然说,我们这个例子,理论上来说,是可以用永久key的,但是大部分的业务是不行的,所以这里要设置过期时间

问题的出现

这个问题得想一想才行

这个情况是比较极端的,但是不代表没有可能会出现

在这里插入图片描述
极端情况下,我们线程1占有了锁,然后突然业务阻塞了,但是业务阻塞的时间比锁的过期时间还要长,这就会导致业务还没结束,锁已经被释放了!

在这里插入图片描述
那么在高并发的情况下,另外一个线程2,乘虚而入,拿到了锁,并且开始执行业务

而在这个时候,在线程2拿到了锁,线程1突然醒了过来,执行了业务代码,然后去执行释放锁的代码

那么这里就会出问题了,线程1不知道这个锁已经被换了主人了,他直接就把锁释放掉了

那么会导致什么结果呢???

在高并发的情况下,线程3一看没有锁了,就乘虚而入

在这里插入图片描述

线程2还没执行完
线程3就拿到了锁

这样下去,当线程2完成了业务,他就释放了锁,那么此时的线程3本来持有锁的,锁被人删了,后面线程4就乘虚而入

这样就像线程1删了线程2的锁
线程2删了线程3的锁
线程3删了线程4的锁

这样子迭代下去,不出问题才怪

这个问题属于是线程安全问题

解决办法

解决办法的思想也很简单,既然你删错锁了,是因为你不知道此时的锁的主人是谁,你以为是自己的,那么我门只要在锁上写上一个标记,代表着此时的锁是谁的.我们去释放锁的时候,就去判断是不是自己的锁,这样就没什么问题了

代码

在这里插入图片描述
按道理来说这里不应该用线程id来当作标识,因为还是有可能会重复,所以应该用uuid来当标识才对

修改如下
在这里插入图片描述
这样就不会有可能是有重复的问题了

原子性问题的出现

我们看上面的解决办法,好像已经很不错了,但是还是有一个漏洞,那就是这里的流程判断锁是不是自己和释放锁不是一个原子操作

在这里插入图片描述
我们来看这个图,就能看明白,这里是一个很极端的情况

首先线程1拿到锁,然后执行完业务,想要释放锁,按照我们的解决方法,我们获取锁,是不是自己,发现是, 就在这个瞬间,突然线程1发生了阻塞

这里的阻塞,有可能是jvm的垃圾回收所导致,或者其他

当我们阻塞的时间超过了锁的过期时间,就会超时释放锁

那么线程2也会乘虚而入,拿到锁

当线程1醒过来的时候,因为前面已经判断过了,所以就会去删线程2的锁

还是会出现误删问题!!!

当然了,出现这个问题的条件是很苛刻的,就是线程1在判断完锁是自己的时候,突然发生阻塞,并且阻塞的时间超过redis锁的过期时间

解决办法

所以我们要想解决这个棘手的问题,我们就要让判断锁是不是自己和释放锁变成一个原子操作

这里就引出了redis 的lua脚本,它可以做到原子性!

LUA脚本

简单的介绍lua脚本

它是一个脚本语言,有点类似于js

在这里插入图片描述

在redis中,执行lua脚本
在这里插入图片描述

这里的key 和 value可以不用写死,可以作为参数传递

特别要注意这里的KEYS,和ARGV数组,需要注意的是,这里的数组是从1开始的

解决上面的问题

先写一个lua脚本
在这里插入图片描述
脚本的意思就是判断锁 + 释放锁

原先java代码的改变

    /*** 释放锁*/private void unlock(String lockKey,String uuid) {DefaultRedisScript<Long> longDefaultRedisScript = new DefaultRedisScript<>();longDefaultRedisScript.setLocation(new ClassPathResource("unlock.lua"));longDefaultRedisScript.setResultType(Long.class);redisCache.execute(longDefaultRedisScript,Arrays.asList(lockKey),uuid);}