Redis - 分布式锁、Redisson

对客户端身份的判断与删除锁操作的合并，是没有专门的原子性命令的。此时可以通过

Lua 脚本来实现它们的原子性。而对 Lua 脚本的执行，可以通过 eval 命令来完成。

不过， eval 命令在 RedisTemplate 中没有对应的方法，而 Jedis 中具有该同名方法。所以，

需要在代码中首先获取到 Jedis 客户端，然后才能调用 jedis.eval() 。

@GetMapping("/sk5")
public String seckillHandler5() {
    // 为每一个访问的客户端随机生成一个客户端唯一标识
    String clientId = UUID.randomUUID().toString();
    try {
        // 在添加锁的同时为锁指定过期时间，该操作具有原子性
        // 将锁的value设置为clientId
        Boolean lockOK = srt.opsForValue().setIfAbsent(REDIS_LOCK, clientId, 5, TimeUnit.SECONDS);

        if (!lockOK) {
            return "没有抢到锁";
        }
        // 添加锁成功
        // 从Redis中获取库存
        String stock = srt.opsForValue().get("sk:0008");
        int amount = stock == null ? 0 : Integer.parseInt(stock);
        if (amount > 0) {
            // 修改库存后再写回Redis
            srt.opsForValue().set("sk:0008", String.valueOf(--amount));
            return "库丰剩余" + amount + "台";
        }
    } finally {
        // 锁续约，或锁续命
        JedisPool jedisPool = new JedisPool(redisHost, redisPort);
        try (Jedis jedis = jedisPool.getResource()) {
            // 定义Lua脚本。注意，每行最后要有一个空格
            // redis.call()是Lua中对Redis命令的调用函数
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                    "then return redis.call('del', KEYS[1]) " +
                    "end " +
                    "return 0";

            // eval()方法的返回值为脚本script的返回值
            Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(clientId));
            if ("1".equals(eval.toString())) {
                System.out.println("释放锁成功");
            } else {
                System.out.println("释放锁时发生异常");
            }
        }
    }

    return "抱歉，您没有抢到";
}

以上代码仍然是存在问题的：请求 a 的锁过期，但其业务还未执行完毕；请求 b 申请到

了锁，其也正在处理业务。如果此时两个请求都同时修改了共享的库存数据，那么就又会出

现数据不一致的问题，即仍然存在并发问题。在高并发场景下，问题会被无限放大。

对于该问题，可以采用“锁续约”方式解决。即，在当前业务进程开始执行时， fork 出

一个子进程，用于启动一个定时任务。该定时任务的定时时间小于锁的过期时间，其会定时

查看处理当前请求的业务进程的锁是否已被删除。如果已被删除，则子进程结束；如果未被

删除，说明当前请求的业务还未处理完毕，则将锁的时间重新设置为“原过期时间”。这种

方式称为锁续约，也称为锁续命。

@Bean
public Redisson redisson() {
    Config Config = new Config();
    Config.useSingleServer()
            .setAddress(redisHost + ":" + redisPort)
            .setDatabase(0);
    return (Redisson) Redisson.create(Config);
}

在需要使用的类中注入

使用：

@GetMapping("/sk6")
public String seckillHandler6() {
    RLock rLock = redisson.getLock(REDIS_LOCK);
    try {
        // 添加分布式锁
        // Boolean lockOK = rLock.tryLock();
        // 指定锁的过期时间为5秒
        // Boolean lockOK = rLock.tryLock(5, TimeUnit.SECONDS);
        // 指定锁的过期时间为5秒。如果申请锁失败，则最长等待20秒
        Boolean lockOK = rLock.tryLock(20, 5, TimeUnit.SECONDS);

        if (!lockOK) {
            return "没有抢到锁";
        }
        // 添加锁成功
        // 从Redis中获取库存
        String stock = srt.opsForValue().get("sk:0008");
        int amount = stock == null ? 0 : Integer.parseInt(stock);
        if (amount > 0) {
            // 修改库存后再写回Redis
            srt.opsForValue().set("sk:0008", String.valueOf(--amount));
            return "库丰剩余" + amount + "台";
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        // 释放锁
        rLock.unlock();
    }

    return "抱歉，您没有抢到";
}

@Bean("redisson-1")
public Redisson redisson1() {
    Config Config = new Config();
    Config.useSentinelServers()
            .setMasterName("mymaster1")
            .addSentinelAddress("redis:16380", "redis:16381", "redis:16382");
    return (Redisson) Redisson.create(Config);
}

@Bean("redisson-2")
public Redisson redisson2() {
    Config Config = new Config();
    Config.useSentinelServers()
            .setMasterName("mymaster2")
            .addSentinelAddress("redis:26380", "redis:26381", "redis:26382");
    return (Redisson) Redisson.create(Config);
}

@Bean("redisson-3")
public Redisson redisson3() {
    Config Config = new Config();
    Config.useSentinelServers()
            .setMasterName("mymaster3")
            .addSentinelAddress("redis:36380", "redis:36381", "redis:36382");
    return (Redisson) Redisson.create(Config);
}

@GetMapping("/sk7")
public String seckillHandler7() {
    // 定义三个可重入锁
    RLock rLock1 = redisson1.getLock(REDIS_LOCK + "-1");
    RLock rLock2 = redisson2.getLock(REDIS_LOCK + "-2");
    RLock rLock3 = redisson3.getLock(REDIS_LOCK + "-3");

    // 定义红锁
    RLock rLock = new RedissonRedLock(rLock1, rLock2, rLock3);
    try {
        // 添加分布式锁
        Boolean lockOK = rLock.tryLock();

        if (!lockOK) {
            return "没有抢到锁";
        }
        // 添加锁成功
        // 从Redis中获取库存
        String stock = srt.opsForValue().get("sk:0008");
        int amount = stock == null ? 0 : Integer.parseInt(stock);
        if (amount > 0) {
            // 修改库存后再写回Redis
            srt.opsForValue().set("sk:0008", String.valueOf(--amount));
            return "库丰剩余" + amount + "台";
        }
    } finally {
        // 释放锁
        rLock.unlock();
    }

    return "抱歉，您没有抢到";
}

@GetMapping("/sk8")
public String seckillHandler8() {
    RSemaphore rs = redisson.getSemaphore("redis_semaphore");
    try {
        int buy = ThreadLocalRandom.current().nextInt(5) + 1;
        Boolean lockOK = rs.tryAcquire(buy, 10, TimeUnit.SECONDS);

        if (!lockOK) {
            return "没有抢到锁";
        }
        // 添加锁成功
        // 从Redis中获取库存
        String stock = srt.opsForValue().get("sk:0008");
        int amount = stock == null ? 0 : Integer.parseInt(stock);
        if (amount > 0) {
            // 修改库存后再写回Redis
            srt.opsForValue().set("sk:0008", String.valueOf(--amount));
            return "库丰剩余" + amount + "台";
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    return "抱歉，您没有抢到";
}

    @GetMapping("/test2")
    public String test2() {

        RPermitExpirableSemaphore rs = redisson.getPermitExpirableSemaphore("redis_semaphore");
        String permitId = null;
        try {
            // 对信号量的申请（P操作)
            // 申请1个信号，返回辨识ID
            permitId = rs.acquire();
            // 申请1个信号，若没有成功，则最多等待10秒，返回辨识ID
            permitId = rs.tryAcquire(10, TimeUnit.SECONDS);

            // 业务逻辑
            // ……


        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 对信号量的释放（V操作）
            // 释放1个信号量，需要携带辨识ID
            rs.release(permitId);
            boolean releaseOK = rs.tryRelease(permitId);
        }

        return null;
    }

    @GetMapping("/test3")
    public String test3() {
        // 获取闭锁对象（合并线程与条件线程中都需要该代码）
        RCountDownLatch latch = redisson.getCountDownLatch("countDownLatch");

        // 设置闭锁计数器初值，使用该语句的场景：
        // 1)Redis中没有设置该值
        // 2)Redis中设置了该值，但已经变为了0，需要重置
        latch.trySetCount(10);

        // 在合并线程中要等待着闭锁的打开
        try {
            // 阻塞合并线程，直到锁打开
            latch.await();
            // 阻塞合并线程，直到锁打开或5秒后
            latch.await(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        // 条件线程代码
        // 使闭锁计数器减一
        latch.countDown();


        return null;
    }