Redis分佈式鎖升級版RedLock及SpringBoot實現方法

- 獲取鎖（unique_value可以是UUID等）
SET resource_name unique_value NX PX 30000

- 釋放鎖（lua腳本中，一定要比較value，防止誤解鎖）
if redis.call("get",KEYS[1]) == ARGV[1] then 
 return redis.call("del",KEYS[1])
else 
 return 0
end

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
 <groupId>org.redisson</groupId>
 <artifactId>redisson</artifactId>
 <version>3.3.2</version>
</dependency>

Config config = new Config();
config.useSentinelServers().addSentinelAddress("127.0.0.1:6369","127.0.0.1:6379", "127.0.0.1:6389")
 .setMasterName("masterName")
 .setPassword("password").setDatabase(0);
RedissonClient redissonClient = Redisson.create(config);
// 還可以getFairLock(), getReadWriteLock()
RLock redLock = redissonClient.getLock("REDLOCK_KEY");
boolean isLock;
try {
 isLock = redLock.tryLock();
 // 500ms拿不到鎖, 就認為獲取鎖失敗。10000ms即10s是鎖失效時間。
 isLock = redLock.tryLock(500, 10000, TimeUnit.MILLISECONDS);
 if (isLock) {
 //TODO if get lock success, do something;
 }
} catch (Exception e) {
} finally {
 // 無論如何, 最後都要解鎖
 redLock.unlock();
}

protected final UUID id = UUID.randomUUID();
String getLockName(long threadId) {
 return id + ":" + threadId;
}

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
 internalLockLeaseTime = unit.toMillis(leaseTime);
 // 獲取鎖時向5個redis實例發送的命令
 return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
  // 首先分佈式鎖的KEY不能存在，如果確實不存在，那麼執行hset命令（hset REDLOCK_KEY uuid+threadId 1），並通過pexpire設置失效時間（也是鎖的租約時間）
  "if (redis.call('exists', KEYS[1]) == 0) then " +
   "redis.call('hset', KEYS[1], ARGV[2], 1); " +
   "redis.call('pexpire', KEYS[1], ARGV[1]); " +
   "return nil; " +
  "end; " +
  // 如果分佈式鎖的KEY已經存在，並且value也匹配，表示是當前線程持有的鎖，那麼重入次數加1，並且設置失效時間
  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
   "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
   "redis.call('pexpire', KEYS[1], ARGV[1]); " +
   "return nil; " +
  "end; " +
  // 獲取分佈式鎖的KEY的失效時間毫秒數
  "return redis.call('pttl', KEYS[1]);",
  // 這三個參數分別對應KEYS[1]，ARGV[1]和ARGV[2]
  Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
 // 向5個redis實例都執行如下命令
 return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
  // 如果分佈式鎖KEY不存在，那麼向channel發佈一條消息
  "if (redis.call('exists', KEYS[1]) == 0) then " +
  "redis.call('publish', KEYS[2], ARGV[1]); " +
  "return 1; " +
  "end;" +
  // 如果分佈式鎖存在，但是value不匹配，表示鎖已經被占用，那麼直接返回
  "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
  "return nil;" +
  "end; " +
  // 如果就是當前線程占有分佈式鎖，那麼將重入次數減1
  "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
  // 重入次數減1後的值如果大於0，表示分佈式鎖有重入過，那麼隻設置失效時間，還不能刪除
  "if (counter > 0) then " +
  "redis.call('pexpire', KEYS[1], ARGV[2]); " +
  "return 0; " +
  "else " +
  // 重入次數減1後的值如果為0，表示分佈式鎖隻獲取過1次，那麼刪除這個KEY，並發佈解鎖消息
  "redis.call('del', KEYS[1]); " +
  "redis.call('publish', KEYS[2], ARGV[1]); " +
  "return 1; "+
  "end; " +
  "return nil;",
  // 這5個參數分別對應KEYS[1]，KEYS[2]，ARGV[1]，ARGV[2]和ARGV[3]
  Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));

}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface RedisLock {
 /**
 * 業務鍵
 *
 * @return
 */
 String key();
 /**
 * 鎖的過期秒數,默認是5秒
 *
 * @return
 */
 int expire() default 5;

 /**
 * 嘗試加鎖，最多等待時間
 *
 * @return
 */
 long waitTime() default Long.MIN_VALUE;
 /**
 * 鎖的超時時間單位
 *
 * @return
 */
 TimeUnit timeUnit() default TimeUnit.SECONDS;
}

@Aspect
@Component
public class LockMethodAspect {
 @Autowired
 private RedisLockHelper redisLockHelper;
 @Autowired
 private JedisUtil jedisUtil;
 private Logger logger = LoggerFactory.getLogger(LockMethodAspect.class);

 @Around("@annotation(com.redis.lock.annotation.RedisLock)")
 public Object around(ProceedingJoinPoint joinPoint) {
 Jedis jedis = jedisUtil.getJedis();
 MethodSignature signature = (MethodSignature) joinPoint.getSignature();
 Method method = signature.getMethod();

 RedisLock redisLock = method.getAnnotation(RedisLock.class);
 String value = UUID.randomUUID().toString();
 String key = redisLock.key();
 try {
  final boolean islock = redisLockHelper.lock(jedis,key, value, redisLock.expire(), redisLock.timeUnit());
  logger.info("isLock : {}",islock);
  if (!islock) {
  logger.error("獲取鎖失敗");
  throw new RuntimeException("獲取鎖失敗");
  }
  try {
  return joinPoint.proceed();
  } catch (Throwable throwable) {
  throw new RuntimeException("系統異常");
  }
 } finally {
  logger.info("釋放鎖");
  redisLockHelper.unlock(jedis,key, value);
  jedis.close();
 }
 }
}

@Component
public class RedisLockHelper {
 private long sleepTime = 100;
 /**
 * 直接使用setnx + expire方式獲取分佈式鎖
 * 非原子性
 *
 * @param key
 * @param value
 * @param timeout
 * @return
 */
 public boolean lock_setnx(Jedis jedis,String key, String value, int timeout) {
 Long result = jedis.setnx(key, value);
 // result = 1時，設置成功，否則設置失敗
 if (result == 1L) {
  return jedis.expire(key, timeout) == 1L;
 } else {
  return false;
 }
 }

 /**
 * 使用Lua腳本，腳本中使用setnex+expire命令進行加鎖操作
 *
 * @param jedis
 * @param key
 * @param UniqueId
 * @param seconds
 * @return
 */
 public boolean Lock_with_lua(Jedis jedis,String key, String UniqueId, int seconds) {
 String lua_scripts = "if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then" +
  "redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end";
 List<String> keys = new ArrayList<>();
 List<String> values = new ArrayList<>();
 keys.add(key);
 values.add(UniqueId);
 values.add(String.valueOf(seconds));
 Object result = jedis.eval(lua_scripts, keys, values);
 //判斷是否成功
 return result.equals(1L);
 }

 /**
 * 在Redis的2.6.12及以後中,使用 set key value [NX] [EX] 命令
 *
 * @param key
 * @param value
 * @param timeout
 * @return
 */
 public boolean lock(Jedis jedis,String key, String value, int timeout, TimeUnit timeUnit) {
 long seconds = timeUnit.toSeconds(timeout);
 return "OK".equals(jedis.set(key, value, "NX", "EX", seconds));
 }

 /**
 * 自定義獲取鎖的超時時間
 *
 * @param jedis
 * @param key
 * @param value
 * @param timeout
 * @param waitTime
 * @param timeUnit
 * @return
 * @throws InterruptedException
 */
 public boolean lock_with_waitTime(Jedis jedis,String key, String value, int timeout, long waitTime,TimeUnit timeUnit) throws InterruptedException {
 long seconds = timeUnit.toSeconds(timeout);
 while (waitTime >= 0) {
  String result = jedis.set(key, value, "nx", "ex", seconds);
  if ("OK".equals(result)) {
  return true;
  }
  waitTime -= sleepTime;
  Thread.sleep(sleepTime);
 }
 return false;
 }
 /**
 * 錯誤的解鎖方法—直接刪除key
 *
 * @param key
 */
 public void unlock_with_del(Jedis jedis,String key) {
 jedis.del(key);
 }

 /**
 * 使用Lua腳本進行解鎖操縱，解鎖的時候驗證value值
 *
 * @param jedis
 * @param key
 * @param value
 * @return
 */
 public boolean unlock(Jedis jedis,String key,String value) {
 String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then " +
  "return redis.call('del',KEYS[1]) else return 0 end";
 return jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(value)).equals(1L);
 }
}

@RestController
public class TestController {
 @RedisLock(key = "redis_lock")
 @GetMapping("/index")
 public String index() {
 return "index";
 }
}