当前位置：首页 > news >正文

3.优惠券秒杀

news 来源：原创 2025/5/11 7:51:25

3.1 全局唯一 ID

当用户抢购时，就会生成订单并保存到 tb_voucher_order 这张表中，而订单表如果使用数据库自增 ID 就存在一些问题：

id 的规律性太明显
受单表数据量的限制

场景分析一：如果我们的 id 具有太明显的规则，用户或者说商业对手很容易猜测出来我们的一些敏感信息，比如商城在一天时间内，卖出了多少单，这明显不合适。

场景分析二：随着我们商城规模越来越大，mysql 的单表的容量不宜超过 500W，数据量过大之后，我们要进行拆库拆表，但拆分表了之后，他们从逻辑上讲他们是同一张表，所以他们的 id 是不能一样的，于是乎我们需要保证 id 的唯一性。

全局 ID 生成器，是一种在分布式系统下用来生成全局唯一 ID 的工具，一般要满足下列特性：
在这里插入图片描述

为了增加 ID 的安全性，我们可以不直接使用 Redis 自增的数值，而是拼接一些其它信息：

在这里插入图片描述

ID 的组成部分：

符号位：1bit，永远为 0
时间戳：31bit，以秒为单位，可以使用 69 年
序列号：32bit，秒内的计数器，支持每秒产生 2^32 个不同 ID

3.2 添加优惠券

每个店铺都可以发布优惠券，分为平价券和特价券。平价券可以任意购买，而特价券需要秒杀抢购：

tb_voucher：优惠券的基本信息，优惠金额、使用规则等
tb_seckill_voucher：优惠券的库存、开始抢购时间，结束抢购时间。特价优惠券才需要填写这些信息
平价卷由于优惠力度并不是很大，所以是可以任意领取

而代金券由于优惠力度大，所以像第二种卷，就得限制数量，从表结构上也能看出，特价卷除了具有优惠卷的基本信息以外，还具有库存，抢购时间，结束时间等等字段

3.3 秒杀下单

秒杀下单应该思考的内容：

下单时需要判断两点：
- 秒杀是否开始或结束，如果尚未开始或已经结束则无法下单
- 库存是否充足，不足则无法下单
下单核心逻辑分析：
- 当用户开始进行下单，我们应当去查询优惠卷信息，查询到优惠卷信息，判断是否满足秒杀条件
- 比如时间是否充足，如果时间充足，则进一步判断库存是否足够，如果两者都满足，则扣减库存，创建订单，然后返回订单 id，如果有一个条件不满足则直接结束。

在这里插入图片描述

3.4 超卖问题

有关超卖问题分析：在我们原有代码中是这么写的

 if (voucher.getStock() < 1) {// 库存不足return Result.fail("库存不足！");}//5，扣减库存boolean success = seckillVoucherService.update().setSql("stock= stock -1").eq("voucher_id", voucherId).update();if (!success) {//扣减库存return Result.fail("库存不足！");}

假设线程 1 过来查询库存判断出来库存大于 1
正准备去扣减库存，但是还没有来得及去扣减
此时线程 2 过来，线程 2 也去查询库存，发现这个数量一定也大于 1
那么这两个线程都会去扣减库存，最终多个线程相当于一起去扣减库存
此时就会出现库存的超卖问题。

在这里插入图片描述

3.5 解决方案

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

而对于加锁，我们通常有两种解决方案：见下图：

在这里插入图片描述

悲观锁：

悲观锁可以实现对于数据的串行化执行，比如 syn，和 lock 都是悲观锁的代表，同时，悲观锁中又可以再细分为公平锁，非公平锁，可重入锁，等等

乐观锁：

会有一个版本号，每次操作数据会对版本号 +1，再提交回数据时，会去校验是否比之前的版本大 1，如果大 1，则进行操作成功，这套机制的核心逻辑在于，如果在操作过程中，版本号只比原来大 1，那么就意味着操作过程中没有人对他进行过修改，他的操作就是安全的，如果不大 1，则数据被修改过，当然乐观锁还有一些变种的处理方式比如 cas

乐观锁的典型代表：就是 cas，利用 cas 进行无锁化机制加锁，var5 是操作前读取的内存值，while 中的 var1+var2 是预估值，如果预估值 == 内存值，则代表中间没有被人修改过，此时就将新值去替换内存值

课程中的使用方式是没有像 cas 一样带自旋的操作，也没有对 version 的版本号 +1，他的操作逻辑是在操作时，对版本号进行 +1 操作，然后要求 version 如果是 1 的情况下，才能操作，那么第一个线程在操作后，数据库中的 version 变成了 2，但是他自己满足 version=1，所以没有问题，此时线程 2 执行，线程 2 最后也需要加上条件 version =1，但是现在由于线程 1 已经操作过了，所以线程 2，操作时就不满足 version=1 的条件了，所以线程 2 无法执行成功

在这里插入图片描述

boolean success = seckillVoucherService.update().setSql("stock= stock -1") //set stock = stock -1.eq("voucher_id", voucherId).eq("stock",voucher.getStock()).update(); //where id = ？ and stock = ?

以上逻辑的核心含义是：只要我扣减库存时的库存和之前我查询到的库存是一样的，就意味着没有人在中间修改过库存，那么此时就是安全的，但是以上这种方式通过测试发现会有很多失败的情况，失败的原因在于：在使用乐观锁过程中假设 100 个线程同时都拿到了 100 的库存，然后大家一起去进行扣减，但是 100 个人中只有 1 个人能扣减成功，其他的人在处理时，他们在扣减时，库存已经被修改过了，所以此时其他线程都会失败

之前的方式要修改前后都保持一致，但是这样我们分析过，成功的概率太低，所以我们的乐观锁需要变一下，改成 stock 大于 0 即可

boolean success = seckillVoucherService.update().setSql("stock= stock -1").eq("voucher_id", voucherId).update().gt("stock",0); 
//where id = ? and stock > 0

CAS:

针对 cas 中的自旋压力过大，我们可以使用 Longaddr 这个类去解决
Java8 提供的一个对 AtomicLong 改进后的一个类，LongAdder
大量线程并发更新一个原子性的时候，天然的问题就是自旋，会导致并发性问题，当然这也比我们直接使用 syn 来的好
所以利用这么一个类，LongAdder 来进行优化
如果获取某个值，则会对 cell 和 base 的值进行递增，最后返回一个完整的值

在这里插入图片描述

3.6 一人一单

需求：修改秒杀业务，要求同一个优惠券，一个用户只能下一单

现在的问题在于：

优惠卷是为了引流，但是目前的情况是，一个人可以无限制的抢这个优惠卷，所以我们应当增加一层逻辑，让一个用户只能下一个单，而不是让一个用户下多个单

具体操作逻辑如下：

比如时间是否充足，如果时间充足
则进一步判断库存是否足够
然后再根据优惠卷 id 和用户 id 查询是否已经下过这个订单
如果下过这个订单，则不再下单，否则进行下单

在这里插入图片描述

// 一人一单逻辑
Long userId = UserHolder.getUser().getId();
Long count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
// 判断是否存在
if (count > 0) {// 用户已经购买过了return Result.fail("用户已经购买过一次！");
}

问题：

多线程情况下（该用户）可能多个线程同时判断到 count == 0，然后都去执行下面的逻辑增加订单…

解决：

封装方法，加 synchronized 锁

@Transactional
public synchronized Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();// 5.1.查询订单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();// 5.2.判断是否存在if (count > 0) {// 用户已经购买过了return Result.fail("用户已经购买过一次！");}// 6.扣减库存boolean success = seckillVoucherService.update().setSql("stock = stock - 1") // set stock = stock - 1.eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0.update();if (!success) {// 扣减失败return Result.fail("库存不足！");}// 7.创建订单VoucherOrder voucherOrder = new VoucherOrder();// 7.1.订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);// 7.2.用户idvoucherOrder.setUserId(userId);// 7.3.代金券idvoucherOrder.setVoucherId(voucherId);save(voucherOrder);// 7.返回订单idreturn Result.ok(orderId);
}

但是这样添加锁，锁的粒度太粗了，在使用锁过程中，控制**锁粒度** 是一个非常重要的事情，因为如果锁的粒度太大，会导致每个线程进来都会锁住，所以我们需要去控制锁的粒度，以下这段代码需要修改为：

intern（）这个方法是从常量池中拿到数据，如果我们直接使用 userId.toString（）他拿到的对象实际上是不同的对象，new 出来的对象，我们使用锁必须保证锁必须是同一把，所以我们需要使用 intern（）方法

@Transactional
public  Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();synchronized(userId.toString().intern()){// 5.1.查询订单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();// 5.2.判断是否存在if (count > 0) {// 用户已经购买过了return Result.fail("用户已经购买过一次！");}// 6.扣减库存boolean success = seckillVoucherService.update().setSql("stock = stock - 1") // set stock = stock - 1.eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0.update();if (!success) {// 扣减失败return Result.fail("库存不足！");}// 7.创建订单VoucherOrder voucherOrder = new VoucherOrder();// 7.1.订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);// 7.2.用户idvoucherOrder.setUserId(userId);// 7.3.代金券idvoucherOrder.setVoucherId(voucherId);save(voucherOrder);// 7.返回订单idreturn Result.ok(orderId);}
}

但是以上代码还是存在问题，问题的原因在于当前方法被 spring 的事务控制，如果你在方法内部加锁，可能会导致当前方法事务还没有提交，但是锁已经释放也会导致问题，所以我们选择将当前方法整体包裹起来，确保事务不会出现问题：如下：

在 seckillVoucher 方法中，添加以下逻辑，这样就能保证事务的特性，同时也控制了锁的粒度

3.7 并发问题

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

1、我们将服务启动两份，端口分别为 8081 和 8082：

NjU6MTc0Njg2OTg2NV9WNA&pos_id=img-0n0b7Wnj-1746866267631)

2、然后修改 nginx 的 conf 目录下的 nginx.conf 文件，配置反向代理和负载均衡：

在这里插入图片描述

有关锁失效原因分析

由于现在我们部署了多个 tomcat，每个 tomcat 都有一个属于自己的 jvm，那么假设在服务器 A 的 tomcat 内部，有两个线程，这两个线程由于使用的是同一份代码，那么他们的锁对象是同一个，是可以实现互斥的，但是如果现在是服务器 B 的 tomcat 内部，又有两个线程，但是他们的锁对象写的虽然和服务器 A 一样，但是锁对象却不是同一个，所以线程 3 和线程 4 可以实现互斥，但是却无法和线程 1 和线程 2 实现互斥，这就是集群环境下，syn 锁失效的原因，在这种情况下，我们就需要使用分布式锁来解决这个问题。

在这里插入图片描述