浅聊 Redis如何实现秒杀(二)（redisson实现秒杀）

在上一篇的基础上，我们实现一人一单的功能

一人一单的情况下，我们就不可以使用乐观锁了，只能使用synchronized锁

public Result createVoucherOrder(Long voucherId) {
        // 5.一人一单
        Long userId = UserHolder.getUser().getId();

        synchronized (userId.toString().intern()) {
            // 5.1.查询订单
            int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
            // 5.2.判断是否存在
            if (count > 0) {
                // 用户已经购买过了
                return Result.fail("用户已经购买过一次！");
            }

            // 6.扣减库存
            boolean success = seckillVoucherService.update()
                    .setSql("stock = stock - 1") // set stock = stock - 1
                    .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                    .update();
            if (!success) {
                // 扣减失败
                return Result.fail("库存不足！");
            }

            // 7.创建订单
            VoucherOrder voucherOrder = new VoucherOrder();
            // 7.1.订单id
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            // 7.2.用户id
            voucherOrder.setUserId(userId);
            // 7.3.代金券id
            voucherOrder.setVoucherId(voucherId);
            save(voucherOrder);

            // 7.返回订单id
            return Result.ok(orderId);
        }
    }

使用synchronized可以解决单机环境下一人一单的问题，但是在集群环境下就不行了；这个时候我们就需要使用分布式锁；

分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。

基于Redis的分布式锁

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

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

释放锁：

手动释放

超时释放：获取锁时添加一个超时时间

public class SimpleRedisLock implements ILock {

    private String name; //锁的名字
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    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);
    }

   
    public void unlock() {
            stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

public Result createVoucherOrder1(Long voucherId) {
        // 5.一人一单
        Long userId = UserHolder.getUser().getId();

        // 创建锁对象
        SimpleRedisLock redisLock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        // 尝试获取锁
        boolean isLock = redisLock.tryLock(1200);
        // 判断
        if(!isLock){
            // 获取锁失败，直接返回失败或者重试
            return Result.fail("不允许重复下单！");
        }

        try {
            // 5.1.查询订单
            int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
            // 5.2.判断是否存在
            if (count > 0) {
                // 用户已经购买过了
                return Result.fail("用户已经购买过一次！");
            }

            // 6.扣减库存
            boolean success = seckillVoucherService.update()
                    .setSql("stock = stock - 1") // set stock = stock - 1
                    .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                    .update();
            if (!success) {
                // 扣减失败
                return Result.fail("库存不足！");
            }

            // 7.创建订单
            VoucherOrder voucherOrder = new VoucherOrder();
            // 7.1.订单id
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            // 7.2.用户id
            voucherOrder.setUserId(userId);
            // 7.3.代金券id
            voucherOrder.setVoucherId(voucherId);
            save(voucherOrder);

            // 7.返回订单id
            return Result.ok(orderId);
        } finally {
            // 释放锁
            redisLock.unlock();
        }
    }

以上是通过redis的分布式锁解决集群下多个JVM不能使用同一个对象锁的方法，但是以上代码还有一个问题，就是如果线程1先获取到锁并设置锁的ttl时间为10秒，正常情况下线程1执行业务方法只需要1秒钟，但是今天的网络延迟特别严重，线程1执行了11秒中，但是锁在10秒钟的时候失效了，10秒后线程2就可以获取锁；

开始线程2的代码，11秒的时候线程1会去清除锁对象，这个时候线程1就把线程2的锁给清除了，然后线程3又会立马进来，这就导致了线程并发的情况，所以我们解决的方法是每个线程在删除锁对象的时候，加个判断，判断这个锁对象是不是自己创建的锁对象；

 public void unlock() {
        // 获取线程标示
        String threadId = Thread.currentThread().getId();
        // 获取锁中的标示
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        // 判断标示是否一致
        if(threadId.equals(id)) {
            // 释放锁
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }