Redis - 分布式锁、Redisson

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

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

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

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

@GetMapping("/sk5")
public String seckillHandler5() {// 为每一个访问的客户端随机生成一个客户端唯一标识String clientId = UUID.randomUUID().toString();try {// 在添加锁的同时为锁指定过期时间，该操作具有原子性// 将锁的value设置为clientIdBoolean 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) {// 修改库存后再写回Redissrt.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) {// 修改库存后再写回Redissrt.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) {// 修改库存后再写回Redissrt.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) {// 修改库存后再写回Redissrt.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个信号，返回辨识IDpermitId = rs.acquire();// 申请1个信号，若没有成功，则最多等待10秒，返回辨识IDpermitId = rs.tryAcquire(10, TimeUnit.SECONDS);// 业务逻辑// ……} catch (Exception e) {e.printStackTrace();} finally {// 对信号量的释放（V操作）// 释放1个信号量，需要携带辨识IDrs.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;}