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。

相关文章

Java docx4j高效处理Word文档的实战指南

Java docx4j高效处理Word文档的实战指南

《Javadocx4j高效处理Word文档的实战指南》对于需要在Java应用程序中生成、修改或处理Word文档的开发者来说,docx4j是一个强大而专业的选择,下面我们就来看看docx4j的具体使用... 目录引言一、环境准备与基础配置1.1 Maven依赖配置1.2 初始化测试类二、增强版文档操作示例2.
阅读更多...
Redis中Stream详解及应用小结

Redis中Stream详解及应用小结

《Redis中Stream详解及应用小结》RedisStreams是Redis5.0引入的新功能,提供了一种类似于传统消息队列的机制,但具有更高的灵活性和可扩展性,本文给大家介绍Redis中Strea... 目录1. Redis Stream 概述2. Redis Stream 的基本操作2.1. XADD
阅读更多...
MySQL 多列 IN 查询之语法、性能与实战技巧(最新整理)

MySQL 多列 IN 查询之语法、性能与实战技巧(最新整理)

《MySQL多列IN查询之语法、性能与实战技巧(最新整理)》本文详解MySQL多列IN查询,对比传统OR写法,强调其简洁高效,适合批量匹配复合键,通过联合索引、分批次优化提升性能,兼容多种数据库... 目录一、基础语法：多列 IN 的两种写法1. 直接值列表2. 子查询二、对比传统 OR 的写法三、性能分析
阅读更多...
Python办公自动化实战之打造智能邮件发送工具

Python办公自动化实战之打造智能邮件发送工具

《Python办公自动化实战之打造智能邮件发送工具》在数字化办公场景中,邮件自动化是提升工作效率的关键技能,本文将演示如何使用Python的smtplib和email库构建一个支持图文混排,多附件,多... 目录前言一、基础配置：搭建邮件发送框架1.1 邮箱服务准备1.2 核心库导入1.3 基础发送函数二、
阅读更多...
Jenkins分布式集群配置方式

Jenkins分布式集群配置方式

《Jenkins分布式集群配置方式》：本文主要介绍Jenkins分布式集群配置方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1.安装jenkins2.配置集群总结Jenkins是一个开源项目，它提供了一个容易使用的持续集成系统，并且提供了大量的plugin满
阅读更多...
PowerShell中15个提升运维效率关键命令实战指南

PowerShell中15个提升运维效率关键命令实战指南

《PowerShell中15个提升运维效率关键命令实战指南》作为网络安全专业人员的必备技能,PowerShell在系统管理、日志分析、威胁检测和自动化响应方面展现出强大能力,下面我们就来看看15个提升... 目录一、PowerShell在网络安全中的战略价值二、网络安全关键场景命令实战1. 系统安全基线核查
阅读更多...
Knife4j+Axios+Redis前后端分离架构下的 API 管理与会话方案(最新推荐)

Knife4j+Axios+Redis前后端分离架构下的 API 管理与会话方案(最新推荐)

《Knife4j+Axios+Redis前后端分离架构下的API管理与会话方案(最新推荐)》本文主要介绍了Swagger与Knife4j的配置要点、前后端对接方法以及分布式Session实现原理,... 目录一、Swagger 与 Knife4j 的深度理解及配置要点Knife4j 配置关键要点1.Spri
阅读更多...
从入门到精通MySQL联合查询

从入门到精通MySQL联合查询

《从入门到精通MySQL联合查询》：本文主要介绍从入门到精通MySQL联合查询,本文通过实例代码给大家介绍的非常详细,需要的朋友可以参考下... 目录摘要1. 多表联合查询时mysql内部原理2. 内连接3. 外连接4. 自连接5. 子查询6. 合并查询7. 插入查询结果摘要前面我们学习了数据库设计时要满
阅读更多...
从原理到实战深入理解Java 断言assert

从原理到实战深入理解Java 断言assert

《从原理到实战深入理解Java断言assert》本文深入解析Java断言机制,涵盖语法、工作原理、启用方式及与异常的区别,推荐用于开发阶段的条件检查与状态验证,并强调生产环境应使用参数验证工具类替代... 目录深入理解 Java 断言（assert）：从原理到实战引言：为什么需要断言？一、断言基础1.1 语
阅读更多...
从入门到精通C++11 ＜chrono＞ 库特性

从入门到精通C++11 ＜chrono＞ 库特性

《从入门到精通C++11＜chrono＞库特性》chrono库是C++11中一个非常强大和实用的库,它为时间处理提供了丰富的功能和类型安全的接口,通过本文的介绍,我们了解了chrono库的基本概念... 目录一、引言1.1 为什么需要<chrono>库1.2<chrono>库的基本概念二、时间段（Durat
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2