hmdp-redis分布式锁

什么是分布式锁呢？

满足分布式系统或集群模式下多进程可见并且互斥的锁。分布式锁的核心思想就是让大家都使用同一把锁，只要大家使用的是同一把锁，那么我们就能锁住线程，不让线程进行，让程序串行执行，这就是分布式锁的核心思路

常见的分布式锁有三种：mysql，redis，zookeeper

mysql：利用本身的锁机制，但是由于mysql性能本身一般，所以采用分布式锁的情况下，其实使用mysql作为分布式锁比较少见

redis：redis作为分布式锁是非常常见的一种使用方式，现在企业级开发中基本都使用redis或者zookeeper作为分布式锁，利用setnx这个方法，如果插入key成功，则表示获得到了锁，如果有人插入成功，其他人插入失败则表示无法获得到锁，利用这套逻辑来实现分布式锁

zookeeper：Zookeeper 是基于临时顺序节点以及 Watcher 监听器机制实现分布式锁的

Redis分布式锁的实现核心思路：

实现分布式锁时需要实现两个基本方法：

获取锁：

       互斥：确保只有一个线程获取锁

        非阻塞：尝试一次，成功返回true，失败返回false

释放锁：

        手动释放

        超时释放：因为可能程序处理会发生一些不可预见的异常，为了避免死锁，所以需要设置锁的过期时间。

尝试获取锁：

private static final String KEY_PREFIX="lock:"
@Override
public boolean tryLock(long timeoutSec) {
    // 获取线程标示
    String threadId = Thread.currentThread().getId()
    // 获取锁
    Boolean success = stringRedisTemplate.opsForValue()
            .setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(success);
}

利用setnx方法进行加锁，同时增加过期时间，防止程序出异常导致死锁的情况发生

释放锁：

public void unlock() {
    //通过del删除锁
    stringRedisTemplate.delete(KEY_PREFIX + name);
}

修改Service层面的代码

 @Override
    public Result SeckillVoucher(Long voucherId) {
        //用户id
        UserDTO user = UserHolder.getUser();
        //查询优惠券
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        //查看秒杀是否开始
        LocalDateTime beginTime = seckillVoucher.getBeginTime();
        System.out.println(LocalDateTime.now());
        if (LocalDateTime.now().isBefore(beginTime)) {
            //未开始
            return Result.fail("秒杀尚未开始");
        }
        LocalDateTime endTime = seckillVoucher.getEndTime();
        //查看秒杀是否结束
        if (LocalDateTime.now().isAfter(endTime)) {
            //已经结束
            return Result.fail("秒杀已经结束");
        }
        //查看库存是否充足
        Integer stock = seckillVoucher.getStock();
        if (stock < 1) {
            //库存不足
            return Result.fail("库存不足");
        }
        /*
         * The reason why locks should not be applied to methods is that if locks are applied to methods,
         * the object of the current lock is the entire method.
         * Therefore, when a large number of threads come in at the same time,
         * only one thread can obtain the lock, so the program becomes serial execution, which is very inefficient.
         */
        /*
         * Because the createVoucherOrder method opens the transaction, but the transaction is managed by Spring,
         * and the transaction cannot be committed until the method is executed,
         * the lock should not be placed inside the createVoucherOrder method
         */
       /* synchronized (UserHolder.getUser().getId().toString().intern()) {
            // 获取代理对象(事务)
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }*/
        SimpleRedisILock iLock = new SimpleRedisILock(stringRedisTemplate, "order" + user.getId());
        boolean isLock = iLock.tryLock(1200);
        //判断是否获取锁成功
        if (!isLock) {
            //获取失败
            //
            return Result.fail("请勿重复操作");
        }
        //获取成功
        try {
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            iLock.unlock();
        }
        return Result.ok(voucherId);
    }

public Result createVoucherOrder(Long voucherId) {
        //一人一单
        //查询订单
        int count = query().eq("user_id", UserHolder.getUser().getId()).eq("voucher_id", voucherId).count();
        System.out.println(count);
        System.out.println("debug");
        if (count > 0) {
            //用户已下单
            return Result.fail("用户已经购买");
        }
        //扣减库存
        /**
         * gt:? > ?
         */
        boolean success = seckillVoucherService.update().setSql("stock = stock -1").gt("stock", 0).eq("voucher_id", voucherId).update();
        if (!success) {
            //扣减失败
            return Result.fail("库存不足");
        }
        //创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);

        voucherOrder.setUserId(UserHolder.getUser().getId());
        //代金券id
        voucherOrder.setVoucherId(voucherId);
        //返回订单id
        save(voucherOrder);
        return Result.ok(orderId);
    }

因为下单的操作需要涉及到两个表的操作，所以这里需要开启事务，因此给createVoucherOrder方法添加@Transactional注解，但是因为Spring是基于代理的方式实现事务功能的，因为你调用的方法，其实是this.的方式调用的，事务想要生效，还得利用代理来生效，所以这个地方，我们需要获得原始的事务对象， 来操作事务