Redis从入门到精通(七)Redis实战(四)库存超卖、一人一单与Redis分布式锁

2024-04-07 15:12
文章标签 实战 入门 精通 redis 分布式 超卖 库存 一人 一单

本文主要是介绍Redis从入门到精通(七)Redis实战(四)库存超卖、一人一单与Redis分布式锁，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

↑↑↑请在文章开头处下载测试项目源代码↑↑↑

文章目录

    • 前言
    • 4.3 优惠券秒杀
      • 4.3.4 库存超卖问题及其解决
        • 4.3.4.1 问题分析
        • 4.3.4.2 问题解决
      • 4.3.5 一人一单需求
        • 4.3.5.1 需求分析
        • 4.3.5.2 代码实现
        • 4.3.5.3 并发问题
        • 4.3.5.4 悲观锁解决并发问题
        • 4.3.5.5 集群环境下的并发问题
    • 4.4 分布式锁
      • 4.4.1 分布式锁介绍
      • 4.4.2 Redis分布式锁的实现核心思路
      • 4.4.3 代码实现分布式锁

前言

Redis实战系列文章：

Redis从入门到精通(四)Redis实战(一)短信登录
Redis从入门到精通(五)Redis实战(二)商户查询缓存
Redis从入门到精通(六)Redis实战(三)优惠券秒杀

4.3 优惠券秒杀

4.3.4 库存超卖问题及其解决

4.3.4.1 问题分析

如上图所示，线程1查询库存，判断当前库存是1，正准备扣减库存，但还没来得及扣减完成，此时线程2也过来查询库存，线程2的查询结果也必然是1，因此也去扣减库存。最终结果是，线程1和线程2都扣减库存，但总库存只有1，从而出现库存超卖问题。

库存超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁。

常见的锁分为悲观锁和乐观锁：

乐观锁一般有一个版本号，每次操作数据都会对版本号+1，提交数据后，会校验版本号是否比之前大1，如果是则说明操作成功，如果不是则说明数据还被其他线程修改过，则操作失败。如下图：

4.3.4.2 问题解决

本项目采用的是校验库存是否被修改过。 修改后的代码如下：

// com.star.redis.dzdp.service.impl.VoucherOrderServiceImpl#seckillVoucher()// 4.扣减库存
// boolean update = seckillVoucherService.update().setSql("stock = stock - 1")
//        .eq("voucher_id", voucherId).update();// 修改方案一
// where voucher_id = ? and stock = ?
boolean update = seckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).eq("stock", seckillVoucher.getStock()).update();

以上代码的含义是，在扣减库存时需要校验库存是否和查询时的库存一致，一致的话则说明没有其他人修改过库存，是安全的，可以进行扣减；否则不能进行扣减。

但以上代码还是有一点问题的，假设有100个线程同时拿到了100个库存，然后同时进行库存扣减，正常来讲所有线程都可以成功扣减，但使用以上代码时只有一个线程可以成功扣减（where voucher_id = ? and stock = 100），其余99个线程都会失败。这就导致失败率太高。

我们可以做如下修改：

// com.star.redis.dzdp.service.impl.VoucherOrderServiceImpl#seckillVoucher()// 修改方案二
// where voucher_id = ? and stock > 0
boolean update = seckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();

以上代码中，不管其他线程是否扣减库存，只要判断出当前库存还大于0，就说明是安全的，当前线程就可以进行扣减。 这样也可以解决库存超卖问题。

4.3.5 一人一单需求

4.3.5.1 需求分析

现在有一个需求：同一个秒杀优惠券，一个用户只能下一单。

目前情况下，一个用户可以无限制地抢优惠券，因此要实现一人一单，就需要增加以下逻辑：在秒杀已开始、且库存充足的情况下，根据优惠券ID和用户ID查询是否已有订单，如果已有订单，则不能再下单。 如下图：

4.3.5.2 代码实现

在VoucherOrderServiceImpl实现类的seckillVoucher()方法中增加一人一单逻辑：

// com.star.redis.dzdp.service.impl.VoucherOrderServiceImpl#seckillVoucher()// 3.判断库存是否充足...// 增加一人一单规则
// 根据优惠券ID和用户ID查询订单是否已存在
int count = query().eq("voucher_id", voucherId).eq("user_id", userId).count();
log.info("old order count = {}", count);
if(count > 0) {// 该用户已下过单return BaseResult.setFail("每个帐号只能抢购一张优惠券！");
}// 4.扣减库存...

简单测试下，调用/voucher/seckill/order接口：

4.3.5.3 并发问题

假设一个线程1过来，根据优惠券ID和用户ID查询订单不存在，准备进行扣减库存和创建订单的动作，但还没来得及完成，另一个线程2也进来了，线程2根据优惠券ID和用户ID查询订单的结果也是不存在，也进行扣减库存和创建订单的动作。最终结果是，创建了同一用户的两个订单。

我们可以在创建订单处打一个断点，调用/voucher/seckill/order接口，下单id=12的优惠券。如日志显示，线程2依次查询秒杀活动是否存在及在有效期内、判断该用户是否重复下单、扣减库存，最终停在断点处：

[http-nio-8081-exec-2] 开始秒杀下单...voucherId = 12, userId = 1012
// 查秒杀活动是否存在及在有效期内
[http-nio-8081-exec-2] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
[http-nio-8081-exec-2] ==> Parameters: 12(Long)
[http-nio-8081-exec-2] <==      Total: 1
[http-nio-8081-exec-2] SeckillVoucher(voucherId=12, stock=999, createTime=Fri Apr 05 18:57:23 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 19:01:44 CST 2024)
// 判断该用户是否重复下单
[http-nio-8081-exec-2] ==>  Preparing: SELECT COUNT( * ) FROM tb_voucher_order WHERE (voucher_id = ? AND user_id = ?)
[http-nio-8081-exec-2] ==> Parameters: 12(Long), 1012(Long)
[http-nio-8081-exec-2] <==      Total: 1
// 扣减库存
[http-nio-8081-exec-2] ==>  Preparing: UPDATE tb_seckill_voucher SET stock = stock - 1 WHERE (voucher_id = ? AND stock > ?)
[http-nio-8081-exec-2] ==> Parameters: 12(Long), 0(Integer)
[http-nio-8081-exec-2] <==    Updates: 1
[http-nio-8081-exec-2] update result = true
[http-nio-8081-exec-2] get orderId = 7354337750083960833

此时再次调用/voucher/seckill/order接口，下单id=12的优惠券。日志限制，新线程5仍然查询订单不存在，会直接创建订单：

[http-nio-8081-exec-5] 开始秒杀下单...voucherId = 12, userId = 1012
// 查秒杀活动是否存在及在有效期内
[http-nio-8081-exec-5] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
[http-nio-8081-exec-5] ==> Parameters: 12(Long)
[http-nio-8081-exec-5] <==      Total: 1
[http-nio-8081-exec-5] SeckillVoucher(voucherId=12, stock=999, createTime=Fri Apr 05 18:57:23 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 19:01:44 CST 2024)
// 判断该用户是否重复下单，仍然是没有
[http-nio-8081-exec-5] ==>  Preparing: SELECT COUNT( * ) FROM tb_voucher_order WHERE (voucher_id = ? AND user_id = ?)
[http-nio-8081-exec-5] ==> Parameters: 12(Long), 1012(Long)
[http-nio-8081-exec-5] <==      Total: 1
// 扣减库存
[http-nio-8081-exec-5] ==>  Preparing: UPDATE tb_seckill_voucher SET stock = stock - 1 WHERE (voucher_id = ? AND stock > ?)
[http-nio-8081-exec-5] ==> Parameters: 12(Long), 0(Integer)
[http-nio-8081-exec-5] <==    Updates: 1
[http-nio-8081-exec-5] update result = true
// 创建订单
[http-nio-8081-exec-5] get orderId = 7354337754378928129
[http-nio-8081-exec-5] ==>  Preparing: INSERT INTO tb_voucher_order ( id, user_id, voucher_id, pay_time ) VALUES ( ?, ?, ?, ? )
[http-nio-8081-exec-5] ==> Parameters: 7354337754378928129(Long), 1012(Long), 12(Long), 2024-04-05 19:06:33.4(Timestamp)
[http-nio-8081-exec-5] <==    Updates: 1

放开断点，原线程2继续创建订单：

// 线程2继续创建订单
[http-nio-8081-exec-2] ==>  Preparing: INSERT INTO tb_voucher_order ( id, user_id, voucher_id, pay_time ) VALUES ( ?, ?, ?, ? )
[http-nio-8081-exec-2] ==> Parameters: 7354337750083960833(Long), 1012(Long), 12(Long), 2024-04-05 19:06:32.351(Timestamp)
[http-nio-8081-exec-2] <==    Updates: 1

此时数据库订单表有两条订单记录：

4.3.5.4 悲观锁解决并发问题

乐观锁比较适合更新数据，此处是插入数据问题，因此可以使用悲观锁来处理。*我们可以把查询订单、扣减库存、创建订单这三步封装为一个方法，并在该方法上添加一把synchronized锁。

// com.star.redis.dzdp.service.impl.VoucherOrderServiceImpl// 方法上添加synchronized锁
public synchronized BaseResult<Long> checkAndCreateVoucherOrder(Long voucherId, Long userId) {log.info("begin checkAndCreateVoucherOrder... voucherId = {}, userId = {}",voucherId, userId);// 1.增加一人一单规则int count = query().eq("voucher_id", voucherId).eq("user_id", userId).count();log.info("old order count = {}", count);if(count > 0) {// 该用户已下过单return BaseResult.setFail("每个帐号只能抢购一张优惠券！");}// 2.扣减库存boolean update = seckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();log.info("update result = {}", update);if(!update) {// 扣减库存失败，返回抢券失败return BaseResult.setFail("库存不足，抢券失败！");}// 3.创建订单VoucherOrder voucherOrder = new VoucherOrder();Long orderId = RedisIdWorker.nextId(stringRedisTemplate, "voucher_order");log.info("get orderId = {}", orderId);voucherOrder.setId(orderId);voucherOrder.setUserId(userId);voucherOrder.setVoucherId(voucherId);voucherOrder.setPayTime(new Date());voucherOrderService.save(voucherOrder);// 4.返回订单IDreturn BaseResult.setOkWithData(orderId);
}

再次以相同的步骤进行测试，日志打印如下：

[http-nio-8081-exec-5] 开始秒杀下单...voucherId = 13, userId = 1012
[http-nio-8081-exec-5] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
[http-nio-8081-exec-5] ==> Parameters: 13(Long)
[http-nio-8081-exec-5] <==      Total: 1
[http-nio-8081-exec-5] SeckillVoucher(voucherId=13, stock=996, createTime=Fri Apr 05 19:30:37 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 19:38:06 CST 2024)
// 线程5进入锁方法
[http-nio-8081-exec-5] begin checkAndCreateVoucherOrder... voucherId = 13, userId = 1012
[http-nio-8081-exec-5] ==>  Preparing: SELECT COUNT( * ) FROM tb_voucher_order WHERE (voucher_id = ? AND user_id = ?)
[http-nio-8081-exec-5] ==> Parameters: 13(Long), 1012(Long)
[http-nio-8081-exec-5] <==      Total: 1
[http-nio-8081-exec-5] old order count = 0
[http-nio-8081-exec-5] ==>  Preparing: UPDATE tb_seckill_voucher SET stock = stock - 1 WHERE (voucher_id = ? AND stock > ?)
[http-nio-8081-exec-5] ==> Parameters: 13(Long), 0(Integer)
[http-nio-8081-exec-5] <==    Updates: 1
[http-nio-8081-exec-5] update result = true
[http-nio-8081-exec-5] get orderId = 7354346232644370433
[http-nio-8081-exec-5] ==>  Preparing: INSERT INTO tb_voucher_order ( id, user_id, voucher_id, pay_time ) VALUES ( ?, ?, ?, ? )
[http-nio-8081-exec-5] ==> Parameters: 7354346232644370433(Long), 1012(Long), 13(Long), 2024-04-05 19:39:27.61(Timestamp)
[http-nio-8081-exec-5] <==    Updates: 1
// 线程5结束
// 线程6开始
[http-nio-8081-exec-6] 开始秒杀下单...voucherId = 13, userId = 1012
[http-nio-8081-exec-6] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
[http-nio-8081-exec-6] ==> Parameters: 13(Long)
[http-nio-8081-exec-6] <==      Total: 1
[http-nio-8081-exec-6] SeckillVoucher(voucherId=13, stock=995, createTime=Fri Apr 05 19:30:37 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 19:39:27 CST 2024)
// 线程6进入锁方法
[http-nio-8081-exec-6] begin checkAndCreateVoucherOrder... voucherId = 13, userId = 1012
[http-nio-8081-exec-6] ==>  Preparing: SELECT COUNT( * ) FROM tb_voucher_order WHERE (voucher_id = ? AND user_id = ?)
[http-nio-8081-exec-6] ==> Parameters: 13(Long), 1012(Long)
[http-nio-8081-exec-6] <==      Total: 1
// 线程6查询发现订单已存在，不再继续往下执行
[http-nio-8081-exec-6] old order count = 1

查看此时的数据库，只有1条voucher_id=13的优惠券订单:

可见，加synchronized锁之后，只有一个线程可以进入checkAndCreateVoucherOrder()方法，也就是只有一个线程可以顺利地创建订单。等锁释放后，其他线程会发现订单已创建，而直接返回错误信息。

4.3.5.5 集群环境下的并发问题

通过加synchronized锁可以解决在单机情况下的“一人一单”安全问题，但是在集群模式下就不行了。 如下图：

集群模式下，由于们部署了多个tomcat，每个tomcat都有一个属于自己的jvm。假设在服务器A的tomcat内部，有两个线程，这两个线程由于使用的是同一份代码，它们的锁对象是同一个，是可以实现互斥的。

但是如果服务器B的tomcat内部，又有两个线程，它们的锁对象写的内容虽然和服务器A一样，但是由于是不同的jvm所以锁对象却不是同一个，所以线程3和线程4可以实现互斥，但是却无法和线程1和线程2实现互斥。

这就是集群环境下，synchronized锁失效的原因，在这种情况下，就需要使用分布式锁来解决这个问题。

4.4 分布式锁

4.4.1 分布式锁介绍

分布式锁即满足分布式系统或集群模式下多进程可见并且互斥的锁。它的核心思想就是，让所有线程都使用同一把锁，从而让线程串行执行。 如图：

分布式锁一般需要满足以下条件：

  • 可见性：多个线程能看到相同的结果。
  • 互斥性：互斥是分布式锁的最基本的条件，使得程序串行执行。
  • 高可用：程序不易崩溃，时时刻刻都保证较高的可用性。
  • 高性能：由于加锁本身就让性能降低，所有对于分布式锁则要求较高的加锁性能和释放锁性能。
  • 安全性：保证数据安全。

常见的分布式锁有三种：

  • MySQL：MySQL本身就带有锁机制，但是由于MySQL性能本身一般，所以使用MySQL作为分布式锁比较少见。
  • Redis：Redis作为分布式锁是非常常见的一种使用方式，利用其SETNX方法，如果插入Key成功，则表示获得到了锁，其他线程则无法获得到锁。
  • Zookeeper：zookeeper也是企业级开发中较好的一个实现分布式锁的方案。

本案例使用Redis分布式锁。

4.4.2 Redis分布式锁的实现核心思路

如上图所示，利用Redis的SETNX方法。当第一个线程进入时，Redis中没有"lock"这个Key，则SETNX方法返回true，表示成功获取到了锁，该线程继续执行其他业务逻辑，最后释放锁。

在释放锁之前，如果有第二个线程进来，由于Redis中已经存在"lock"这个Key，所以SETNX方法返回false，表示没有获取到锁，则等待一段时间后继续重试。

4.4.3 代码实现分布式锁

首先创建一个ILock接口，定义加锁和解锁的两个基本方法：

// com.star.redis.dzdp.utils.ILockpublic interface ILock {/*** 尝试获取锁* @author hsgx* @since 2024/4/5 21:07* @param timeout 超时时间* @return boolean*/boolean tryLock(long timeout);/*** 释放锁* @author hsgx* @since 2024/4/5 21:07* @param* @return void*/void unlock();}

然后创建一个SimpleRedisLock类实现ILock接口，重写基本方法：

// com.star.redis.dzdp.utils.SimpleRedisLock@Slf4j
public class SimpleRedisLock implements ILock {private String key;private StringRedisTemplate stringRedisTemplate;public SimpleRedisLock(String key, StringRedisTemplate stringRedisTemplate) {this.key = key;this.stringRedisTemplate = stringRedisTemplate;}@Overridepublic boolean tryLock(long timeout) {// 1.获取线程IDlong threadId = Thread.currentThread().getId();// 2.获取锁，并设置超时时间Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent("lock:" + key, threadId + "", timeout, TimeUnit.SECONDS);log.info("set to Redis : Key = {}, Value = {}. set result = {}", "lock:" + key, threadId, flag);// 3.返回return BooleanUtil.isTrue(flag);}@Overridepublic void unlock() {// 1.释放锁Boolean flag = stringRedisTemplate.delete("lock:" + key);log.info("del from to Redis : Key = {}. del result = {}", "lock:" + key, flag);}}

最后修改业务代码：

// com.star.redis.dzdp.service.impl.VoucherOrderServiceImpl@Override
public BaseResult<Long> seckillVoucher(Long voucherId, Long userId) {log.info("开始秒杀下单...voucherId = {}, userId = {}", voucherId, userId);// 1.查询秒杀优惠券信息SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);// 2.判断秒杀活动是否开启或结束if(seckillVoucher == null) {// 秒杀活动不存在return BaseResult.setFail("秒杀活动不存在！");} else if(seckillVoucher.getBeginTime().after(new Date())) {// 秒杀活动未开始log.info("beginTime = {}", seckillVoucher.getBeginTime());return BaseResult.setFail("秒杀尚未开始！");} else if(seckillVoucher.getEndTime().before(new Date())) {// 秒杀活动已结束log.info("endTime = {}", seckillVoucher.getEndTime());return BaseResult.setFail("秒杀已结束！");}log.info("{}", seckillVoucher.toString());// 3.判断库存是否充足if(seckillVoucher.getStock() < 1) {// 库存不足return BaseResult.setFail("库存不足，抢券失败！");}// 创建锁对象SimpleRedisLock simpleRedisLock = new SimpleRedisLock("voucher_order:" + userId, stringRedisTemplate);// 尝试获取锁boolean lock = simpleRedisLock.tryLock(1200);// 加锁失败，则说明该用户已有一条线程if(!lock) {return BaseResult.setFail("每个帐号只能抢购一张优惠券！");}// 加锁成功，则执行业务代码try {return checkAndCreateVoucherOrder(voucherId, userId);} finally {// 释放锁simpleRedisLock.unlock();}
}

下面模拟有3个线程同时到达，其日志打印如下：

// 用户ID=1012的线程10
[http-nio-8081-exec-10] token from client => ccedd4ea-c73e-42cd-b9f2-3a637cbcca9b
[http-nio-8081-exec-10] user from redis => {"id":1012,"phone":"18922102124","password":"","nickName":"18922102124","icon":"","createTime":1712041918000,"updateTime":1712041918000}
[http-nio-8081-exec-10] 开始秒杀下单...voucherId = 14, userId = 1012
[http-nio-8081-exec-10] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
// 用户ID=1012的线程1
[http-nio-8081-exec-1] token from client => ccedd4ea-c73e-42cd-b9f2-3a637cbcca9b
[http-nio-8081-exec-10] ==> Parameters: 14(Long)
// 用户ID=1012的线程9
[http-nio-8081-exec-9] token from client => ccedd4ea-c73e-42cd-b9f2-3a637cbcca9b
[http-nio-8081-exec-9] user from redis => {"id":1012,"phone":"18922102124","password":"","nickName":"18922102124","icon":"","createTime":1712041918000,"updateTime":1712041918000}
[http-nio-8081-exec-1] user from redis => {"id":1012,"phone":"18922102124","password":"","nickName":"18922102124","icon":"","createTime":1712041918000,"updateTime":1712041918000}
[http-nio-8081-exec-10] <==      Total: 1
[http-nio-8081-exec-10] SeckillVoucher(voucherId=14, stock=999, createTime=Fri Apr 05 19:36:15 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 21:27:47 CST 2024)
[http-nio-8081-exec-1] 开始秒杀下单...voucherId = 14, userId = 1012
// 线程10拿到了互斥锁
[http-nio-8081-exec-10] set to Redis : Key = lock:voucher_order:1012, Value = 42. set result = true
[http-nio-8081-exec-9] 开始秒杀下单...voucherId = 14, userId = 1012
[http-nio-8081-exec-10] begin checkAndCreateVoucherOrder... voucherId = 14, userId = 1012
[http-nio-8081-exec-1] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
[http-nio-8081-exec-9] ==>  Preparing: SELECT voucher_id,stock,create_time,begin_time,end_time,update_time FROM tb_seckill_voucher WHERE voucher_id=?
[http-nio-8081-exec-1] ==> Parameters: 14(Long)
[http-nio-8081-exec-9] ==> Parameters: 14(Long)
[http-nio-8081-exec-10] ==>  Preparing: SELECT COUNT( * ) FROM tb_voucher_order WHERE (voucher_id = ? AND user_id = ?)
[http-nio-8081-exec-10] ==> Parameters: 14(Long), 1012(Long)
[http-nio-8081-exec-1] <==      Total: 1
[http-nio-8081-exec-1] SeckillVoucher(voucherId=14, stock=999, createTime=Fri Apr 05 19:36:15 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 21:27:47 CST 2024)
[http-nio-8081-exec-10] <==      Total: 1
[http-nio-8081-exec-9] <==      Total: 1
[http-nio-8081-exec-10] old order count = 0
[http-nio-8081-exec-9] SeckillVoucher(voucherId=14, stock=999, createTime=Fri Apr 05 19:36:15 CST 2024, beginTime=Fri Apr 05 14:00:00 CST 2024, endTime=Sat Apr 06 18:00:00 CST 2024, updateTime=Fri Apr 05 21:27:47 CST 2024)
// 线程1没有拿到互斥锁
[http-nio-8081-exec-1] set to Redis : Key = lock:voucher_order:1012, Value = 33. set result = false
// 线程9没有拿到互斥锁
[http-nio-8081-exec-9] set to Redis : Key = lock:voucher_order:1012, Value = 41. set result = false
// 最终只有线程10进行扣减库存和创建订单
[http-nio-8081-exec-10] ==>  Preparing: UPDATE tb_seckill_voucher SET stock = stock - 1 WHERE (voucher_id = ? AND stock > ?)
[http-nio-8081-exec-10] ==> Parameters: 14(Long), 0(Integer)
[http-nio-8081-exec-10] <==    Updates: 1
[http-nio-8081-exec-10] update result = true
[http-nio-8081-exec-10] get orderId = 7354374484939243521
[http-nio-8081-exec-10] ==>  Preparing: INSERT INTO tb_voucher_order ( id, user_id, voucher_id, pay_time ) VALUES ( ?, ?, ?, ? )
[http-nio-8081-exec-10] ==> Parameters: 7354374484939243521(Long), 1012(Long), 14(Long), 2024-04-05 21:29:05.933(Timestamp)
[http-nio-8081-exec-10] <==    Updates: 1
[http-nio-8081-exec-10] del from to Redis : Key = lock:voucher_order:1012. del result = true

可见，三条线程只有一条线程可以拿到锁，并执行扣减库存和创建订单的逻辑，其余两条线程均拿不到锁，也就无法扣减库存和创建订单。

…

本节完，更多内容请查阅分类专栏：Redis从入门到精通

感兴趣的读者还可以查阅我的另外几个专栏：

  • SpringBoot源码解读与原理分析(已完结)
  • MyBatis3源码深度解析(已完结)
  • 再探Java为面试赋能(持续更新中…)

这篇关于Redis从入门到精通(七)Redis实战(四)库存超卖、一人一单与Redis分布式锁的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/882941。

相关文章

Python与DeepSeek的深度融合实战

Python与DeepSeek的深度融合实战

《Python与DeepSeek的深度融合实战》Python作为最受欢迎的编程语言之一,以其简洁易读的语法、丰富的库和广泛的应用场景,成为了无数开发者的首选,而DeepSeek,作为人工智能领域的新星... 目录一、python与DeepSeek的结合优势二、模型训练1. 数据准备2. 模型架构与参数设置3
阅读更多...
Java实战之利用POI生成Excel图表

Java实战之利用POI生成Excel图表

《Java实战之利用POI生成Excel图表》ApachePOI是Java生态中处理Office文档的核心工具,这篇文章主要为大家详细介绍了如何在Excel中创建折线图,柱状图,饼图等常见图表,需要的... 目录一、环境配置与依赖管理二、数据源准备与工作表构建三、图表生成核心步骤1. 折线图（Line Ch
阅读更多...
Java使用Tesseract-OCR实战教程

Java使用Tesseract-OCR实战教程

《Java使用Tesseract-OCR实战教程》本文介绍了如何在Java中使用Tesseract-OCR进行文本提取,包括Tesseract-OCR的安装、中文训练库的配置、依赖库的引入以及具体的代... 目录Java使用Tesseract-OCRTesseract-OCR安装配置中文训练库引入依赖代码实
阅读更多...
使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

《使用sql-research-assistant进行SQL数据库研究的实战指南(代码实现演示)》本文介绍了sql-research-assistant工具,该工具基于LangChain框架,集... 目录技术背景介绍核心原理解析代码实现演示安装和配置项目集成LangSmith 配置（可选）启动服务应用场景
阅读更多...
redis群集简单部署过程

redis群集简单部署过程

《redis群集简单部署过程》文章介绍了Redis,一个高性能的键值存储系统,其支持多种数据结构和命令,它还讨论了Redis的服务器端架构、数据存储和获取、协议和命令、高可用性方案、缓存机制以及监控和... 目录Redis介绍1. 基本概念2. 服务器端3. 存储和获取数据4. 协议和命令5. 高可用性6.
阅读更多...
Redis的数据过期策略和数据淘汰策略

Redis的数据过期策略和数据淘汰策略

《Redis的数据过期策略和数据淘汰策略》本文主要介绍了Redis的数据过期策略和数据淘汰策略,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一... 目录一、数据过期策略1、惰性删除2、定期删除二、数据淘汰策略1、数据淘汰策略概念2、8种数据淘汰策略
阅读更多...
在Java中使用ModelMapper简化Shapefile属性转JavaBean实战过程

在Java中使用ModelMapper简化Shapefile属性转JavaBean实战过程

《在Java中使用ModelMapper简化Shapefile属性转JavaBean实战过程》本文介绍了在Java中使用ModelMapper库简化Shapefile属性转JavaBean的过程,对比... 目录前言一、原始的处理办法1、使用Set方法来转换2、使用构造方法转换二、基于ModelMapper
阅读更多...
Java实战之自助进行多张图片合成拼接

Java实战之自助进行多张图片合成拼接

《Java实战之自助进行多张图片合成拼接》在当今数字化时代,图像处理技术在各个领域都发挥着至关重要的作用,本文为大家详细介绍了如何使用Java实现多张图片合成拼接,需要的可以了解下... 目录前言一、图片合成需求描述二、图片合成设计与实现1、编程语言2、基础数据准备3、图片合成流程4、图片合成实现三、总结前
阅读更多...
Redis存储的列表分页和检索的实现方法

Redis存储的列表分页和检索的实现方法

《Redis存储的列表分页和检索的实现方法》在Redis中,列表（List）是一种有序的数据结构,通常用于存储一系列元素,由于列表是有序的,可以通过索引来访问元素,因此可以很方便地实现分页和检索功能,... 目录一、Redis 列表的基本操作二、分页实现三、检索实现3.1 方法 1：客户端过滤3.2 方法
阅读更多...
Python中操作Redis的常用方法小结

Python中操作Redis的常用方法小结

《Python中操作Redis的常用方法小结》这篇文章主要为大家详细介绍了Python中操作Redis的常用方法,文中的示例代码简洁易懂,具有一定的借鉴价值,有需要的小伙伴可以了解一下... 目录安装Redis开启、关闭Redisredis数据结构redis-cli操作安装redis-py数据库连接和释放增
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2