Redis分布式锁

简单的分布式锁

利用下面的命令，实现一个带自动删除的分布式锁

set key value  px 毫秒  nx

编写两个lua脚本文件

加锁

-- 利用set key value px milliseconds nx 命令实现分布式锁
redis.call('set',KEYS[1],ARGV[1],'px',ARGV[2],'nx')

释放锁

-- 比较线程标示与锁的标示是否一致
if (redis.call('get',KEYS[1]) == ARGV[1]) then
    -- 释放锁
    return redis.call('del',KEYS[1])
end
return 0

具体代码：

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

代码：

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());
    }
}

更多文章请扫码关注公众号，有问题的小伙伴也可以在公众号上提出。