Loading

四、Redis企业实战 - 优惠劵秒杀

在喧嚣之外 孤单 戒掉 廉价的浪漫

全局唯一ID生成

每个店铺都可以发布优惠券,当用户抢购时,就会生成订单并保存到tb_voucher_order这张表中。

而订单表如果使用数据库自增ID就存在一些问题:

  • id的规律性太明显

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

  • 受单表数据量的限制

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

全局唯一ID生成需要满足的特性:

为了增加ID的安全性,不要直接使用Redis自增的数值,而是拼接一些其它信息。

在实际开发中:

  • ID的组成部分:符号位:1bit,永远为0。

  • 时间戳:31bit,以秒为单位,可以使用69年。

  • 序列号:32bit,秒内的计数器,支持每秒产生2^32个不同ID。

唯一ID生成工具类
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

/**
* @Description 全局唯一Id生成器
* @Author LH
* @Date 2022/11/17 14:06
**/
@Component
public class RedisIdWorker {
   /**
    * 开始时间戳
    * 2022-01-01 00:00:00
    */
   private static final long BEGIN_TIMESTAMP = 1640966400L;

   /**
    * 拼接序列号的位数
    */
   private static final int COUNT_BITS = 32;

   @Resource
   private StringRedisTemplate stringRedisTemplate;

   /**
    * 生成唯一id
    *
    * @param keyPrefix 业务前缀key
    * @return id
    */
   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 redis自增长
       Long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

       // 3. 拼接唯一id返回
       return timeStamp << COUNT_BITS | count;
  }
}

测试

    @Test
   void testIdWorker() throws InterruptedException {
       CountDownLatch latch = new CountDownLatch(300);

       Runnable task = () -> {
           for (int i = 0; i < 100; i++) {
               long id = redisIdWorker.nextId("order");
               System.out.println(id);
          }
           latch.countDown();
      };

       long begin = System.currentTimeMillis();
       for (int i = 0; i < 300; i++) {
           es.submit(task);
      }
       latch.await();
       long end = System.currentTimeMillis();
       System.out.println("time = " + (end - begin));
  }
countdownlatch

countdownlatch名为信号枪:主要的作用是同步协调在多线程的等待于唤醒问题

由于程序是异步的,当异步程序没有执行完时,主线程就已经执行完了,然后我们期望的是分线程全部走完之后,主线程再走,所以我们此时需要使用到CountDownLatch。

CountDownLatch 中有两个主要方法:

  • countDown

  • await

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

常见的唯一ID生成策略
  • UUID

  • Redis自增

  • snowflake算法

  • 数据库自增

  • redis自增ID策略

优惠劵的秒杀下单

正常的下单流程需要判断两点:

  1. 秒杀是否开始或结束,如果尚未开始或已经结束则无法下单

  2. 库存是否充足,不足则无法下单

在多线程的情况下,会出现库存超卖问题

库存超卖问题的解决方案

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

乐观锁的关键是,查询时不加锁,在进行数据更新时再进行一次判断。

乐观锁的使用:

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

乐观锁解决超卖问题

关键代码

boolean success = seckillVoucherService.update()
          .setSql("stock= stock -1")
          .eq("voucher_id", voucherId).update().gt("stock",0);

先查询库存信息,这时候不加锁,在进行库存更新时,在更新语句中判断库存值是否大于0

超卖问题总结:

  1. 悲观锁:添加同步锁,让线程串行执行

    • 优点:简单粗暴

    • 缺点:性能一般

  2. 乐观锁:不加锁,在更新时判断是否有其它线程在修改

    • 优点:性能好

    • 缺点:存在成功率低的问题(如:在使用乐观锁过程中假设100个线程同时都拿到了100的库存,然后大家一起去进行扣减,但是100个人中只有1个人能扣减成功,其他的人在处理时,他们在扣减时,库存已经被修改过了,所以此时其他线程都会失败 )

优惠券秒杀 - 一人一单

需求:要求同一个优惠券,一个用户只能下一单

代码示例

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
</dependency>
@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.hmdp.mapper")
@SpringBootApplication
public class HmDianPingApplication {

   public static void main(String[] args) {
       SpringApplication.run(HmDianPingApplication.class, args);
  }

}
    @Override
   public Result seckillVoucherById(Long voucherId) {
       // 1. 查询优惠劵
       SeckillVoucher voucher = iSeckillVoucherService.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, userId);
      }
  }

   /**
    * 实现一人一单, 关键在于 事务提交之前锁是否释放
    * 在多线程的情况下,如果当前方法事务没有提交,但是锁已经释放会出现问题
    *
    * @param voucherId 消费券id
    * @return 订单号
    */
   @Transactional
   public Result createVoucherOrder(Long voucherId, Long userId) {
       int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
       // 5. 判断是否存在
       if (count > 0) {
           return Result.fail("用户已经购买过一次!");
      }
       // 6.扣减库存
       boolean success = iSeckillVoucherService.update()
              .setSql("stock = stock - 1")
              .eq("voucher_id", voucherId).gt("stock", 0)
              .update();
       if (!success) {
           return Result.fail("库存不足!");
      }
       // 7.创建订单
       VoucherOrder voucherOrder = new VoucherOrder();
       long orderId = redisIdWorker.nextId("order");
       voucherOrder.setId(orderId);
       voucherOrder.setUserId(userId);
       voucherOrder.setVoucherId(voucherId);
       save(voucherOrder);
       // 8.返回订单id
       return Result.ok(orderId);
  }

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

集群环境下的并发问题

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

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

 
posted @ 2022-11-18 11:35  你比从前快乐;  阅读(145)  评论(0编辑  收藏  举报