几种redis分布式锁实现
一、简单的分布式锁实现
利用下面的命令，实现一个带自动删除的分布式锁
set key value px 毫秒 nx
编写两个lua脚本文件
加锁操作--lock.lua
-- 利用set key value px milliseconds nx 命令实现分布式锁
redis.call('set',KEYS[1],ARGV[1],'px',ARGV[2],'nx')
释放锁操作--unlock.lua
-- 比较线程标示与锁的标示是否一致
if (redis.call('get',KEYS[1]) == ARGV[1]) then
-- 释放锁
return redis.call('del',KEYS[1])
end
return 0
文件放在项目的Resource目录下
代码实现
public class RedisLock {
private final StringRedisTemplate stringRedisTemplate;
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
private static final DefaultRedisScript<Long> LOCK_SCRIPT;
public RedisLock(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
this.releaseTime = 1000L;
}
static {
UNLOCK_SCRIPT = new DefaultRedisScript<>();
UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
UNLOCK_SCRIPT.setResultType(Long.class);
LOCK_SCRIPT = new DefaultRedisScript<>();
LOCK_SCRIPT.setLocation(new ClassPathResource("lock.lua"));
LOCK_SCRIPT.setResultType(Long.class);
}
/**
* 加锁
*
* @param key
*/
public void myTryLock(String key) {
List<String> list = new ArrayList<>();
list.add(LOCK_KEY + ":" + key);
Long expireTime = 100000L;
String threadId = Thread.currentThread().getName();
// 加锁，过期时间十秒
stringRedisTemplate.execute(LOCK_SCRIPT, list, threadId,expireTime.toString());
}
/**
* 释放锁
*
* @param key
*/
public void myUnLock(String key) {
List<String> list = new ArrayList<>();
list.add(LOCK_KEY + ":" + key);
String threadId = Thread.currentThread().getName();
// 释放锁
stringRedisTemplate.execute(UNLOCK_SCRIPT, list, threadId);
}
}
二、利用map结构实现可重入的分布式锁
编写两个lua脚本文件
加锁操作--reentrelock.lua
-- 获取可重入锁获取锁的lua脚本
local key = KEYS[1]
-- 线程标识
local threadId = ARGV[1]
-- 锁自动释放时间
local releaseTime = ARGV[2]
-- 查看当前线程的锁是否存在
if(redis.call('exists',key) == 0) then
-- 不存在，获取锁
redis.call('hset',key,threadId,'1')
-- 设置有效期
redis.call('expire',key,releaseTime)
return 1
end
-- 如果当前线程的锁已经存在
if(redis.call('hexists',key,threadId) ==1) then
-- 给当前的锁重入次数加一
redis.call('hincrby',key,threadId,'1')
-- 重新设置有效期
redis.call('expire',key,releaseTime)
return 1
end
-- 说明锁不是自己的，获取锁失败
return 0
释放锁操作--reentreunlock.lua
-- 获取可重入锁的释放锁lua脚本
local key = KEYS[1]
-- 线程标识
local threadId = ARGV[1]
-- 锁自动释放时间
local releaseTime = ARGV[2]
-- 查看当前线程的锁是否是自己持有
if(redis.call('hexists',key,threadId) == 0) then
-- 不是自己持有，直接返回
return nil
end
-- 获取重入次数减一后的值
local count = redis.call('hincrby',key,threadId,'-1')
-- 如果大于0说明，锁还有重入次数
if(count > 0) then
-- 重置释放时间
redis.call('expire',key,'10')
return nil
else
-- 说明重入次数为0直接删除
redis.call('del',key)
return nil
end
文件放在项目的Resource目录下
代码实现
public class RedisLock {
private final StringRedisTemplate stringRedisTemplate;
private final Long releaseTime;
private static final DefaultRedisScript<Long> REENTRELOCK_SCRIPT;
private static final DefaultRedisScript<Long> REENTREUNLOCK_SCRIPT;
private final String LOCK_KEY = "lock";
public RedisLock(StringRedisTemplate stringRedisTemplate, Long releaseTime) {
this.stringRedisTemplate = stringRedisTemplate;
this.releaseTime = releaseTime;
}
public RedisLock(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
this.releaseTime = 1000L;
}
static {
REENTRELOCK_SCRIPT = new DefaultRedisScript<>();
REENTRELOCK_SCRIPT.setLocation(new ClassPathResource("reentrelock.lua"));
REENTRELOCK_SCRIPT.setResultType(Long.class);
REENTREUNLOCK_SCRIPT = new DefaultRedisScript<>();
REENTREUNLOCK_SCRIPT.setLocation(new ClassPathResource("reentreunlock.lua"));
REENTREUNLOCK_SCRIPT.setResultType(Long.class);
}
/**
* 获取锁
*/
public boolean tryLock() {
List<String> list = new ArrayList<>();
String threadId = Thread.currentThread().getName();
list.add(LOCK_KEY + threadId);
Long result = stringRedisTemplate.execute(REENTRELOCK_SCRIPT, list, threadId, releaseTime.toString());
return (result != null) && (result == 1L);
}
/**
* 释放锁
*/
public void unLock() {
List<String> list = new ArrayList<>();
String threadId = Thread.currentThread().getName();
list.add(LOCK_KEY + threadId);
stringRedisTemplate.execute(REENTREUNLOCK_SCRIPT, list, threadId, releaseTime.toString());
}
}
三、直接引入redisson，使用redisson实现可以续时的分布式锁
redisson里面的分布式锁其实就是使用的上面的第二种可重入锁实现的，并且它在里面还实现了watchdog（看门狗）这种可以给锁续过期时间的机制。在构建锁对象的时候使用无参的构造即可自动启动看门狗机制。
总结
利用redis实现分布式锁的时候，一定要考虑到操作redis的原子性，如果使用redis的java的api来操作redis，多条命令会调用多次api，高并发情况下就会造成原子性问题。所以建议直接用lua脚本来实现，因为lua脚本是可以保证原子性的。
其他实现分布式锁的方式还有数据库方式，zookeeper方式。简单对比：
