《Redis实战篇》三、优惠券秒杀

谁借莪１个温暖的怀抱￠ 2023-10-07 22:10 10阅读 0赞

#### 文章目录 ####

*   *  3.1 全局唯一ID
     *  3.2 Redis实现全局唯一Id
     *  3.3 添加优惠卷
     *  3.4 实现秒杀下单
     *  3.5 库存超卖问题分析
     *  3.6 乐观锁解决超卖问题
     *  3.7 优惠券秒杀-一人一单
     *  3.8 集群环境下的并发问题
     *

### 3.1 全局唯一ID ###

每个店铺都可以发布优惠券：

![1653362612286][]

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

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

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

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

**全局ID生成器**，是一种在分布式系统下用来生成全局唯一ID的工具，一般要满足下列特性：

![1653363100502][]

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

![1653363172079][]

ID的组成部分：

符号位：1bit，永远为0

时间戳：31bit，以秒为单位，可以使用69年

序列号：32bit，秒内的计数器，支持每秒产生2^32个不同ID

### 3.2 Redis实现全局唯一Id ###

/**
     * @author lxy
     * @version 1.0
     * @Description ID生成器
     * @date 2022/12/12 12:48
     */
    @Component
    public class RedisIdWorker {
        
    
        /**
         * 开始时间戳
         */
        private static final long BEGIN_TIMESTAMP = 1670803200L;
    
        /**
         * 序列号的位数
         */
        private static final long COUNT_BITS = 32;
    
        private StringRedisTemplate stringRedisTemplate;
    
        public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        
            this.stringRedisTemplate = stringRedisTemplate;
        }
    
        public long nextId(String keyPrefix){
        
            // 1.生成时间戳
            LocalDateTime now = LocalDateTime.now();
            long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
            long timestamp = nowSecond - BEGIN_TIMESTAMP;
    
            // 2.生成序列号
            //2.1 获取当天日期，精确到天
            String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
            // 2.2自增长
            Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
    
            // 3.拼接并返回
            return timestamp << COUNT_BITS | count;
        }
    
    }

测试类

@Test
    public void testIdWorker() throws InterruptedException {
        
        CountDownLatch countDownLatch = new CountDownLatch(300);
    
        Runnable task = ()->{
        
            for (int i = 0; i < 100; i++) {
        
                long id = redisIdWorker.nextId("order");
                System.out.println("id = "+id);
            }
            countDownLatch.countDown();
        };
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 300; i++) {
        
            es.submit(task);
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("time = "+(end - begin));
    }

> 知识小贴士：关于countdownlatch
> 
> countdownlatch名为信号枪：主要的作用是同步协调在多线程的等待于唤醒问题
> 
> 我们如果没有CountDownLatch ，那么由于程序是异步的，当异步程序没有执行完时，主线程就已经执行完了，然后我们期望的是分线程全部走完之后，主线程再走，所以我们此时需要使用到CountDownLatch
> 
> CountDownLatch 中有两个最重要的方法
> 
> 1、countDown
> 
> 2、await
> 
> await 方法 是阻塞方法，我们担心分线程没有执行完时，main线程就先执行，所以使用await可以让main线程阻塞，那么什么时候main线程不再阻塞呢？当CountDownLatch 内部维护的 变量变为0时，就不再阻塞，直接放行，那么什么时候CountDownLatch 维护的变量变为0 呢，我们只需要调用一次countDown ，内部变量就减少1，我们让分线程和变量绑定， 执行完一个分线程就减少一个变量，当分线程全部走完，CountDownLatch 维护的变量就是0，此时await就不再阻塞，统计出来的时间也就是所有分线程执行完后的时间。

### 3.3 添加优惠卷 ###

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

![1653365145124][]

tb\_voucher：优惠券的基本信息，优惠金额、使用规则等  
tb\_seckill\_voucher：优惠券的库存、开始抢购时间，结束抢购时间。特价优惠券才需要填写这些信息

平价卷由于优惠力度并不是很大，所以是可以任意领取

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

\*\*新增普通卷代码: \*\* VoucherController

@PostMapping
    public Result addVoucher(@RequestBody Voucher voucher) {
        
        voucherService.save(voucher);
        return Result.ok(voucher.getId());
    }

**新增秒杀卷代码：**

**VoucherController**

@PostMapping("seckill")
    public Result addSeckillVoucher(@RequestBody Voucher voucher) {
        
        voucherService.addSeckillVoucher(voucher);
        return Result.ok(voucher.getId());
    }

**VoucherServiceImpl**

@Override
    @Transactional
    public void addSeckillVoucher(Voucher voucher) {
        
        // 保存优惠券
        save(voucher);
        // 保存秒杀信息
        SeckillVoucher seckillVoucher = new SeckillVoucher();
        seckillVoucher.setVoucherId(voucher.getId());
        seckillVoucher.setStock(voucher.getStock());
        seckillVoucher.setBeginTime(voucher.getBeginTime());
        seckillVoucher.setEndTime(voucher.getEndTime());
        seckillVoucherService.save(seckillVoucher);
        // 保存秒杀库存到Redis中
        stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
    }

### 3.4 实现秒杀下单 ###

下单核心思路：当我们点击抢购时，会触发右侧的请求，我们只需要编写对应的controller即可

![1653365839526][]

下单时需要判断两点：

*  秒杀是否开始或结束，如果尚未开始或已经结束则无法下单
 *  库存是否充足，不足则无法下单

下单核心逻辑分析：

当用户开始进行下单，我们应当去查询优惠卷信息，查询到优惠卷信息，判断是否满足秒杀条件

比如时间是否充足，如果时间充足，则进一步判断库存是否足够，如果两者都满足，则扣减库存，创建订单，然后返回订单id，如果有一个条件不满足则直接结束。

![1653366238564][]

VoucherOrderServiceImpl

@Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        
        // 1.获取优惠券信息
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        // 2.判断秒杀是否开始
        LocalDateTime beginTime = voucher.getBeginTime();
        LocalDateTime endTime = voucher.getEndTime();
        if(beginTime.isAfter(LocalDateTime.now()) || endTime.isBefore(LocalDateTime.now())){
        
            return Result.fail("不再秒杀时段内！");
        }
        // 3.判断库存是否充足
        if(voucher.getStock() < 1){
        
            //库存不足
            return Result.fail("库存不足！");
        }
        // 4.扣减库存
        boolean success = seckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).update();
        //这里二次判断的原因在于：高并发场景下会有时间差A在更新库存的时间内，B把最后一件买走了，就会导致A更新失败！
        if(!success){
        
            return Result.fail("库存不足！");
        }
        // 5.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
    
        // 5.1 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
    
        // 5.2 用户id
        voucherOrder.setUserId(UserHolder.getUser().getId());
    
        // 5.3代金券id
        voucherOrder.setVoucherId(voucherId);
        this.save(voucherOrder);
        return Result.ok(orderId);
    }

**测试：**

当我们用两百个线程模拟秒杀的时候，竟然出现了 库存 -9 的情况，很显然出现了超卖问题~

### 3.5 库存超卖问题分析 ###

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

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，那么这两个线程都会去扣减库存，最终多个线程相当于一起去扣减库存，此时就会出现库存的超卖问题。

![1653368335155][]

超卖问题是典型的多线程安全问题，针对这一问题的常见解决方案就是加锁：而对于加锁，我们通常有两种解决方案：见下图：

![image-20221213200152980][]

**悲观锁：**

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

**乐观锁：**

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

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

其中do while 是为了在操作失败时，再次进行自旋操作，即把之前的逻辑再操作一次。

int var5;
    do {
        
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
    return var5;

**课程中的使用方式：**

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

![1653369268550][]

### 3.6 乐观锁解决超卖问题 ###

**修改代码方案一、**

VoucherOrderServiceImpl 在扣减库存时，改为：

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 = ?

结果：

![image-20221213201606432][]

以上逻辑的核心含义是：只要我扣减库存时的库存和之前我查询到的库存是一样的，就意味着没有人在中间修改过库存，那么此时就是安全的，但是以上这种方式通过测试发现会有很多失败的情况，失败的原因在于：在使用乐观锁过程中假设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中的自旋压力过大，我们可以使用Longaddr这个类去解决

Java8 提供的一个对AtomicLong改进后的一个类，LongAdder

大量线程并发更新一个原子性的时候，天然的问题就是自旋，会导致并发性问题，当然这也比我们直接使用syn来的好

所以利用这么一个类，LongAdder来进行优化

如果获取某个值，则会对cell和base的值进行递增，最后返回一个完整的值

![1653370271627][]

### 3.7 优惠券秒杀-一人一单 ###

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

**现在的问题在于：**

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

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

![1653371854389][]

VoucherOrderServiceImpl

**初步代码：增加一人一单逻辑**

@Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        
        // 1.获取优惠券信息
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        // 2.判断秒杀是否开始
        LocalDateTime beginTime = voucher.getBeginTime();
        LocalDateTime endTime = voucher.getEndTime();
        if(beginTime.isAfter(LocalDateTime.now()) || endTime.isBefore(LocalDateTime.now())){
        
            return Result.fail("不再秒杀时段内！");
        }
        // 3.判断库存是否充足
        if(voucher.getStock() < 1){
        
            //库存不足
            return Result.fail("库存不足！");
        }
    
        // 4. 一人一单
        Long userId = UserHolder.getUser().getId();
        // 4.1 查询订单
        Integer count = this.query().eq("voucher_id", voucherId).eq("user_id", userId).count();
        // 4.2 判断是否存在
        if(count > 0){
        
            return Result.fail("用户已经购买过一次了~");
        }
    
    
        // 5.扣减库存
        boolean success = seckillVoucherService.update().setSql("stock = stock - 1").
            eq("voucher_id", voucherId)
            .gt("stock",0)
            .update();
        //这里二次判断的原因在于：高并发场景下会有时间差A在更新库存的时间内，B把最后一件买走了，就会导致A更新失败！
        if(!success){
        
            return Result.fail("库存不足！");
        }
    
        // 6.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 6.1 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
    
        // 6.2 用户id
        voucherOrder.setUserId(userId);
    
        // 6.3代金券id
        voucherOrder.setVoucherId(voucherId);
        this.save(voucherOrder);
        return Result.ok(orderId);
    }

\*\*存在问题：\*\*现在的问题还是和之前一样，并发过来，查询数据库，都不存在订单，所以我们还是需要加锁，但是乐观锁比较适合更新数据，而现在是插入数据，所以我们需要使用悲观锁操作

**注意：** 在这里提到了非常多的问题，我们需要慢慢的来思考，首先我们的初始方案是封装了一个createVoucherOrder方法，同时为了确保他线程安全，在方法上添加了一把synchronized 锁

@Transactional
    public synchronized Result createVoucherOrder(Long voucherId) {
        
        // 4. 一人一单
        Long userId = UserHolder.getUser().getId();
        // 4.1 查询订单
        Integer count = this.query().eq("voucher_id", voucherId).eq("user_id", userId).count();
        // 4.2 判断是否存在
        if(count > 0){
        
            return Result.fail("用户已经购买过一次了~");
        }
    
    
        // 5.扣减库存
        boolean success = seckillVoucherService.update().setSql("stock = stock - 1").
            eq("voucher_id", voucherId)
            .gt("stock",0)
            .update();
        //这里二次判断的原因在于：高并发场景下会有时间差A在更新库存的时间内，B把最后一件买走了，就会导致A更新失败！
        if(!success){
        
            return Result.fail("库存不足！");
        }
    
        // 6.创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 6.1 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
    
        // 6.2 用户id
        voucherOrder.setUserId(userId);
    
        // 6.3代金券id
        voucherOrder.setVoucherId(voucherId);
        this.save(voucherOrder);
        return Result.ok(orderId);
    }

，但是这样添加锁，锁的粒度太粗了，在使用锁过程中，控制**锁粒度** 是一个非常重要的事情，因为如果锁的粒度太大，会导致每个线程进来都会锁住，所以我们需要去控制锁的粒度，以下这段代码需要修改为：  
intern() 这个方法是从常量池中拿到数据，如果我们直接使用userId.toString() 他拿到的对象实际上是不同的对象，new出来的对象，我们使用锁必须保证锁必须是同一把，所以我们需要使用intern()方法

@Transactional
    public  Result createVoucherOrder(Long voucherId) {
        
        // 4. 一人一单
        Long userId = UserHolder.getUser().getId();
        
        synchronized(userId.toString().intern()){
        
            // 4.1 查询订单
            Integer count = this.query().eq("voucher_id", voucherId).eq("user_id", userId).count();
            // 4.2 判断是否存在
            if(count > 0){
        
                return Result.fail("用户已经购买过一次了~");
            }
    
            // 5.扣减库存
            boolean success = seckillVoucherService.update().setSql("stock = stock - 1").
                    eq("voucher_id", voucherId)
                    .gt("stock",0)
                    .update();
            //这里二次判断的原因在于：高并发场景下会有时间差A在更新库存的时间内，B把最后一件买走了，就会导致A更新失败！
            if(!success){
        
                return Result.fail("库存不足！");
            }
    
            // 6.创建订单
            VoucherOrder voucherOrder = new VoucherOrder();
            // 6.1 订单id
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            // 6.2 用户id
            voucherOrder.setUserId(userId);
            // 6.3代金券id
            voucherOrder.setVoucherId(voucherId);
            this.save(voucherOrder);
            return Result.ok(orderId);
        }
    }

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

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

![image-20221215234431160][]

但是以上做法依然有问题，因为你调用的方法，其实是`this.`的方式调用的，事务想要生效，还得利用代理来生效，所以这个地方，我们需要获得原始的事务对象， 来操作事务

![image-20221215234511307][]

\*\*注意：\*\*代理需要搭配`@EnableAspectJAutoProxy(exposeProxy = true)` 和aspectjweaver 依赖

### 3.8 集群环境下的并发问题 ###

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

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

![image-20221216104419719][]

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

![1653373908620][]

**具体操作(略)**

我们在Postman中发送两个一模一样的秒杀请求，结果发现请求分别进入了两个服务的synchronized方法内，出现了锁失效的问题~

**有关锁失效原因分析**

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

![image-20221216114317798][]

###  ###

[1653362612286]: https://img-blog.csdnimg.cn/img_convert/b24541b93b57c3e0eb0f117074c91d80.png
[1653363100502]: https://img-blog.csdnimg.cn/img_convert/cd8504ad23b175bb6786003c6b461634.png
[1653363172079]: https://img-blog.csdnimg.cn/img_convert/07d4100b625e3ecbc123d28d2198f22d.png
[1653365145124]: https://img-blog.csdnimg.cn/img_convert/90b1db6bd3d59960384c11d50db782f3.png
[1653365839526]: https://img-blog.csdnimg.cn/img_convert/eb8a00129a4427b7f486202cddd53f57.png
[1653366238564]: https://img-blog.csdnimg.cn/img_convert/3e7618180ea07fe0c332196683715656.png
[1653368335155]: https://img-blog.csdnimg.cn/img_convert/3e73acf842c2b1184d1cbb47671666e0.png
[image-20221213200152980]: https://img-blog.csdnimg.cn/img_convert/df43b1dfd4515a01ddf9cce64d8303ed.png
[1653369268550]: https://img-blog.csdnimg.cn/img_convert/18c4ce2870d72ac6992d7314ef01438f.png
[image-20221213201606432]: https://img-blog.csdnimg.cn/img_convert/0bc3c6989b60bd54be5efbed0e4b26ac.png
[1653370271627]: https://img-blog.csdnimg.cn/img_convert/3147e6b41c1170c7de2593883db14f3d.png
[1653371854389]: https://img-blog.csdnimg.cn/img_convert/190d8997808de1f513e93ab7faf65903.png
[image-20221215234431160]: https://img-blog.csdnimg.cn/img_convert/325b58598f2e74d668cd0b6fddc3b2fd.png
[image-20221215234511307]: https://img-blog.csdnimg.cn/img_convert/6ca6fc5c28e5eccd76fd357cd12a3be1.png
[image-20221216104419719]: https://img-blog.csdnimg.cn/img_convert/d1287b3a9fdbcb300f8965195a15fbf0.png
[1653373908620]: https://img-blog.csdnimg.cn/img_convert/e5fe1c618a13f69a5eeb78f91a57868e.png
[image-20221216114317798]: https://img-blog.csdnimg.cn/img_convert/eb8afbe3fb4c48ee7e923e702d749889.png