3 应对秒杀

Redis05 应对秒杀 - 图1

3.1 全局唯一ID

Redis05 应对秒杀 - 图2

Redis05 应对秒杀 - 图3

Redis05 应对秒杀 - 图4

  1. public class RedisIdWorker {
  2.     private static final long START_TIME = LocalDateTime.of(2022, 1, 1, 0, 0, 0).toEpochSecond(ZoneOffset.UTC);
  3.     private static final int COUNT_BITS = 32;
  5.     @Autowired
  6.     private StringRedisTemplate stringRedisTemplate;
  9.     public long nextId(String keyPrefix){
  10.         // 时间戳
  11.         long now = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
  12.         now = now - START_TIME;
  13.         // 生成序列号
  14.         String key = "icr:" + keyPrefix + ":" + LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
  15.         long count = stringRedisTemplate.opsForValue().increment(key);
  16.         // 拼接并返回
  17.         return now << COUNT_BITS | count;
  18.     }
  20.     public static void main(String[] args) {
  21.         int i = 0 << 32 | 100;
  22.         System.out.println(i);
  23.     }
  24. }

Redis05 应对秒杀 - 图5

3.2 秒杀 超卖

Redis05 应对秒杀 - 图6

Redis05 应对秒杀 - 图7Redis05 应对秒杀 - 图8

  1.  seckillVoucher.setStock((seckillVoucher.getStock() - 1));
  2.         boolean update = seckillVoucherService.update()
  3.                 .setSql("stock = stock -1")
  4.                 .eq("voucher_id",voucherId)
  5.                 .gt("stock",0)
  6.                 .update()
  7.                 ;
  8.         if (!update) {
  9.             return Result.fail("优惠卷已售空");
  10.         }
  1. @Transactional
  2.     public Result createUserOrderVoucher(Long voucherId, SeckillVoucher seckillVoucher, LocalDateTime now) {
  3.         Long id = UserHolder.getUser().getId();
  4.         // 对id一样的字符串常量池加锁 不影响 this 这把钥匙的使用权
  5.         // 因为使用的是 防止同一个人下单两次
  6.         synchronized (id.toString().intern()) {
  7.             int count = query().eq("user_id", id).eq("voucher_id", voucherId).count();
  8.             if (count > 0) {
  9.                 return Result.fail("您只能下一单");
  10.             }
  12.             seckillVoucher.setStock((seckillVoucher.getStock() - 1));
  13.             boolean update = seckillVoucherService.update()
  14.                     .setSql("stock = stock -1")
  15.                     .eq("voucher_id", voucherId)
  16.                     .gt("stock", 0)
  17.                     .update();
  18.             if (!update) {
  19.                 return Result.fail("优惠卷已售空");
  20.             }
  22.             VoucherOrder voucherOrder = new VoucherOrder();
  23.             voucherOrder.setId(idWorker.nextId("order"));
  24.             voucherOrder.setUserId(id);
  25.             voucherOrder.setVoucherId(voucherId);
  26.             voucherOrder.setStatus(1);
  27.             voucherOrder.setUpdateTime(now);
  28.             voucherOrder.setCreateTime(now);
  29.             voucherOrder.setPayType(1);
  30.             save(voucherOrder);
  31.             return Result.ok("下单成功！ 请尽快支付！");
  32.         }
  33.     }

微服务情况

Redis05 应对秒杀 - 图9

3.3 分布式锁

redis实现分布式锁相关链接

Redis05 应对秒杀 - 图10

Redis05 应对秒杀 - 图11

Redis05 应对秒杀 - 图12

Redis05 应对秒杀 - 图13

  1. SimpleRedisLock redisLock = new SimpleRedisLock("order:"+id, stringRedisTemplate); // 自定义的锁对象实现
  2. boolean isLock = redisLock.tryLock(10, TimeUnit.SECONDS);
  3. if (!isLock) {
  4.     // TODO 注意 这里的锁对象是不同 进程 同一个 用户 的id 不同用户不会产生争抢锁现象 只会判断 where stock > 0
  5.     return Result.fail("不允许重复下单");
  6. }
  7. try {
  8.     int count = query().eq("user_id", id).eq("voucher_id", voucherId).count();
  9.     if (count > 0) {
  10.         return Result.fail("您只能下一单");
  11.     }
  13.     //    ......
  14.     return Result.ok("下单成功！ 请尽快支付！");
  15.     //}
  16. } finally {
  17.     redisLock.unlock();
  18. }

有时效性key的失效导致key误删问题

Redis05 应对秒杀 - 图14

  1. ## 图解：
  2. - 线程1 获取到锁 但是由于业务执行时间过长导致锁Key失效 直接会使抢夺锁的线程2 获取到锁并且生成key
  3. * 于此同时线程1执行业务完成 直接删除线程2 对应的key 导致线程3 在线程2 执行业务时同时获取到了key 
  4. **导致了一系列数据不一致问题**

Redis05 应对秒杀 - 图15

根据存入的value(Thread.id) 判断释放的线程id是否一致

  1. public class SimpleRedisLock implements ILock {
  2.     private final static String LOCK_PREFIX = "lock:";
  3.     // 每个服务的jvm初始化放在字符串常量池的 中的UUID 作为唯一标识前缀
  4.     private static final String ID_PREFIX = UUID.randomUUID().toString(true);
  5.     private final String name;
  6.     private final StringRedisTemplate stringRedisTemplate;
  9.     public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
  10.         this.name = name;
  11.         this.stringRedisTemplate = stringRedisTemplate;
  12.     }
  15.     @Override
  16.     public boolean tryLock(long timeoutSec,TimeUnit unit) {
  17.         String threadId = ID_PREFIX + Thread.currentThread();
  18.         Boolean ownLock = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_PREFIX + name, threadId,timeoutSec,unit);
  19.         return Boolean.TRUE.equals(ownLock);
  20.     }
  22.     @Override
  23.     public void unlock() {
  24.         String threadId = ID_PREFIX + Thread.currentThread();
  25.         String id = stringRedisTemplate.opsForValue().get(LOCK_PREFIX + name);
  26.         // 判断将要执行删除锁的服务线程是否为加锁线程 解决锁误删问题
  27.         if (! threadId.equals(id)) {
  28.             throw new BusinessLock("释放锁异常");
  29.         }
  30.         stringRedisTemplate.delete(LOCK_PREFIX + name);
  31.     }
  33.     class BusinessLock extends RuntimeException {
  34.         private String msg;
  36.         public BusinessLock(String msg) {
  37.             super(msg);
  38.         }
  40.         public BusinessLock(Throwable cause, String msg) {
  41.             super(msg,cause);
  42.         }
  43.     }
  44. }

阻塞释放问题

Redis05 应对秒杀 - 图16

  1. # 这里是因为线程1 `释放阻塞` 由于前面对比的版本/id是 value 线程1释放是已经判断过的 不会对比value直接删除 `key` 而
  2. # 此时 `key` 中存放的是线程2 的锁value 导致线程3乘虚而入
  4. # 这里 key 一致是要保证分布式多个服务之间互斥 value是防止误删

所以要保证获取锁和释放锁是**原子性操作**

  1. if (! threadId.equals(id)) {
  2.     throw new BusinessLock("释放锁异常");
  3. }
  4. stringRedisTemplate.delete(LOCK_PREFIX + name);
  5. // 这一段执行 `equals`  `delete` 是组合操作 很难保证原子性

lua 保证原子性

Redis05 应对秒杀 - 图17

Redis05 应对秒杀 - 图18

  1. 127.0.0.1:6379> EVAL "return redis.call('mset',KEYS[1],ARGV[1],KEYS[2],ARGV[2])" 2 k1 k2 v1 v2
  3. 127.0.0.1:6379> EVAL "return redis.call('hset',KEYS[1],AVGS[1],AVGS[2])" h1 name zs
  1. local id = redis.call('GET',KEYS[1])
  3. if(id == ARGV[1]) then
  4.   return redis.call('DEL',KEYS[1])
  5. end
  7. return 0

Redis05 应对秒杀 - 图19

Redis05 应对秒杀 - 图20

Redis05 应对秒杀 - 图21

  1. public class SimpleRedisLock implements ILock {
  3.     private final static String LOCK_PREFIX = "lock:";
  4.     // 每个服务的jvm初始化放在字符串常量池的 中的UUID 作为唯一标识前缀
  5.     private static final String ID_PREFIX = UUID.randomUUID().toString(true);
  6.     private final String name;
  7.     private final StringRedisTemplate stringRedisTemplate;
  8.     private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
  10.     public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
  11.         this.name = name;
  12.         this.stringRedisTemplate = stringRedisTemplate;
  13.     }
  15.     static {
  16.         // 加载脚本
  17.         UNLOCK_SCRIPT = new DefaultRedisScript<>();
  18.         UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
  19.         UNLOCK_SCRIPT.setResultType(Long.class);
  20.     }
  22.     @Override
  23.     public boolean tryLock(long timeoutSec, TimeUnit unit) {
  24.         String threadId = ID_PREFIX + Thread.currentThread();
  25.         Boolean ownLock = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_PREFIX + name, threadId, timeoutSec, unit);
  26.         return Boolean.TRUE.equals(ownLock);
  27.     }
  29.     @Override
  30.     public void unlock() {
  31.         Long result = stringRedisTemplate
  32.                 .execute(
  33.                         UNLOCK_SCRIPT,
  34.                         Collections.singletonList(LOCK_PREFIX + name),
  35.                         ID_PREFIX + Thread.currentThread().getId());
  36.         // todo 缩减为一行代码 优化误删问题 但是归根还是超时问题
  37.         if (result == 0) {
  38.             throw new BusinessLock("释放锁异常");
  39.         }
  40.     }
  42.     /*@Override
  43.     public void unlock() {
  44.         String threadId = ID_PREFIX + Thread.currentThread();
  45.         String id = stringRedisTemplate.opsForValue().get(LOCK_PREFIX + name);
  46.         // 判断将要执行删除锁的服务线程是否为加锁线程 解决锁误删问题
  47.         if (! threadId.equals(id)) {
  48.             throw new BusinessLock("释放锁异常");
  49.         }
  50.         stringRedisTemplate.delete(LOCK_PREFIX + name);
  51.     }*/
  53.     class BusinessLock extends RuntimeException {
  54.         private String msg;
  56.         public BusinessLock(String msg) {
  57.             super(msg);
  58.         }
  60.         public BusinessLock(Throwable cause, String msg) {
  61.             super(msg, cause);
  62.         }
  63.     }
  64. }

相关业务层

  1. @Transactional
  2. public Result createUserOrderVoucher(Long voucherId, SeckillVoucher seckillVoucher, LocalDateTime now) {
  3.     Long id = UserHolder.getUser().getId();
  4.     // 对id一样的字符串常量池加锁 不影响 this 这把钥匙的使用权
  5.     // 因为使用的是 防止同一个人下单两次
  6.     // synchronized (id.toString().intern()) {
  7.     // 只锁该对象的下单重复
  8.     // 多用户的秒杀有 where stock > 0 的原子锁保证
  9.     SimpleRedisLock redisLock = new SimpleRedisLock("order:"+id, stringRedisTemplate);
  10.     boolean isLock = redisLock.tryLock(10, TimeUnit.SECONDS);
  11.     if (!isLock) {
  12.         // TODO 注意 这里的锁对象是不同 进程 同一个 用户 的id 不同用户不会产生争抢锁现象 只会判断 where stock > 0
  13.         return Result.fail("不允许重复下单");
  14.     }
  15.     try {
  16.         int count = query().eq("user_id", id).eq("voucher_id", voucherId).count();
  17.         if (count > 0) {
  18.             return Result.fail("您只能下一单");
  19.         }
  21.         seckillVoucher.setStock((seckillVoucher.getStock() - 1));
  22.         boolean update = seckillVoucherService.update()
  23.             .setSql("stock = stock -1")
  24.             .eq("voucher_id", voucherId)
  25.             .gt("stock", 0)
  26.             .update();
  27.         if (!update) {
  28.             return Result.fail("优惠卷已售空");
  29.         }
  31.         VoucherOrder voucherOrder = new VoucherOrder();
  32.         voucherOrder.setId(idWorker.nextId("order"));
  33.         voucherOrder.setUserId(id);
  34.         voucherOrder.setVoucherId(voucherId);
  35.         voucherOrder.setStatus(1);
  36.         voucherOrder.setUpdateTime(now);
  37.         voucherOrder.setCreateTime(now);
  38.         voucherOrder.setPayType(1);
  39.         save(voucherOrder);
  40.         return Result.ok("下单成功！ 请尽快支付！");
  41.         //}
  42.     } finally {
  43.         redisLock.unlock();
  44.     }
  45. }