[Redis实战]优惠券秒杀

三、优惠券秒杀

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 Redis实现全局唯一ID

@Component
public class RedisIdWorker {
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号的位数
     */
    private static final int 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;
    }
}

测试类:

countdownlatch

CountDownLatch 中有两个最重要的方法

1、countDown

2、await

await 方法 是阻塞方法,我们担心分线程没有执行完时,main线程就先执行,所以使用await可以让main线程阻塞,那么什么时候main线程不再阻塞呢?当CountDownLatch 内部维护的 变量变为0时,就不再阻塞,直接放行,那么什么时候CountDownLatch 维护的变量变为0 呢,我们只需要调用一次countDown ,内部变量就减少1,我们让分线程和变量绑定, 执行完一个分线程就减少一个变量,当分线程全部走完,CountDownLatch 维护的变量就是0,此时await就不再阻塞,统计出来的时间也就是所有分线程执行完后的时间。

@Autowired
private RedisIDWorker redisIDWorker;

//创建500个线程
private ExecutorService es = Executors.newFixedThreadPool(500);

@Test
void testIdWorker() throws InterruptedException {
    //总数是300
    CountDownLatch latch = new CountDownLatch(300);

    Runnable task = () -> {
        //每个线程生成100个id
        for (int i = 0; i < 100; i++) {
            long id = redisIDWorker.nextId("order");
            System.out.println("id = " + id);
        }
        //latch-1
        latch.countDown();
    };
    long begin = System.currentTimeMillis();
    //将每个任务提交300次
    for (int i = 0; i < 300; i++) {
        es.submit(task);
    }
    //等待计数器归零,然后再向下执行
    latch.await();
    long end = System.currentTimeMillis();
    System.out.println("time=" + (end - begin));
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.3 添加优惠券

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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即可。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

下单时需要判断两点:

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

VoucherOrderController

@Autowired
private IVoucherOrderService voucherOrderService;

@PostMapping("seckill/{id}")
public Result seckillVoucher(@PathVariable("id") Long voucherId) {
    return voucherOrderService.seckillVoucher(voucherId);
}

VoucherOrderServiceImpl

@Autowired
private ISeckillVoucherService seckillVoucherService;

@Autowired
private RedisIDWorker redisIDWorker;

@Transactional
public Result seckillVoucher(Long voucherId) {
    //1.查询优惠券信息
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    //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 success = seckillVoucherService.update().setSql("stock=stock-1").eq("voucher_id", voucherId).update();
    if (!success) {
        return Result.fail("库存不足!");
    }
    //6.创建订单
    Long orderId = redisIDWorker.nextId("order");
    VoucherOrder order = VoucherOrder.builder().id(orderId).voucherId(voucherId).userId(UserHolder.getUser().getId()).build();
    save(order);
    //7.返回订单id
    return Result.ok(orderId);
}

3.5 库存超卖问题

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

悲观锁

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

乐观锁

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

修改代码方案:使用CAS法

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

3.6 优惠券秒杀-一人一单

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

初步代码:增加一人一单逻辑

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

存在问题:现在的问题还是和之前一样,并发过来,查询数据库,都不存在订单,保证不了一个用户只能下一单,所以我们还需要加锁,但是乐观锁比较适合更新数据,而现在是插入数据,所以我们需要使用悲观锁来操作。

注意:加锁的初始方案是封装一个createVoucherOrder方法,同时为了保证线程安全,在方法上添加了一把synchronized锁,但是这样的锁,锁的粒度太粗了,在使用锁的过程中,控制锁粒度是一个非常重要的事情,因为如果锁的粒度太大,会导致每个线程进来都会锁住,所以我们需要去控制锁的粒度。

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

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

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

完整代码

@Autowired
private ISeckillVoucherService seckillVoucherService;

@Autowired
private RedisIDWorker redisIDWorker;

public Result seckillVoucher(Long voucherId) {
    //1.查询优惠券信息
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    //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);
    }
}

@Transactional
public Result createVoucherOrder(Long voucherId) {
    //5.一人一单
    Long userId = UserHolder.getUser().getId();
    //5.1查询订单
    Integer count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    //5.2判断是否存在
    if (count > 0) {
        //用户已经购买过了
        return Result.fail("用户已经购买过一次!");
    }
    //6.扣减库存
    //update tb_seckill_voucher set stock=stock-1 where voucher_id=? and stock>0;
    boolean success = seckillVoucherService.update()
            .setSql("stock=stock-1")
            .eq("voucher_id", voucherId).gt("stock", 0)
            .update();
    if (!success) {
        return Result.fail("库存不足!");
    }
    //7.创建订单
    Long orderId = redisIDWorker.nextId("order");
    VoucherOrder order = VoucherOrder.builder().id(orderId).voucherId(voucherId).userId(userId).build();
    save(order);
    //8.返回订单id
    return Result.ok(orderId);
}

3.7 集群环境下的并发问题

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

  1. 我们将服务启动两份。端口分别为8081和8083:

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  2. 然后将nginx的conf目录下的nginx.conf文件,配置反向代理和负载均衡:

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

有关锁失效原因分析

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

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传