使用redis实现分布式锁

几种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方式。简单对比：