Redis之分布式锁

Redis之分布式锁

分布式应用进行逻辑处理时经常会遇到并发问题。比如，一个操作要修改用户状态，修改状态需要先读出用户的状态，在内存里进行修改，改完再存进去。如果有多个系统同时今夕操作，就会出现并发问题，因为读取和保存状态这两个操作不是原子的。

这个时候就要使用到分布式锁来限制程序的并发执行。Redis 分布式锁就是最广泛的方案之一。

分布式锁

分布式锁本质上要实现的目标就是在 Redis 里面占有一个位置，当别的进程也要来占用时，发现已经有人占用了，就只能放弃或者稍后再试。

对于这样的操作，我们一般使用 setnx(set if not exists) 指令，只允许一个客户端占用，用完之后再调用 del 指令释放。

> setnx lock true
(integer) 1
> set redis redis // 等一些列操作
OK
> del lock
(integer) 1

如果在 setnx 和 expire(设置过期时间) 之间服务器进程突然挂掉了，可能是因为机器断电或者被杀掉，就会导致 expire 得不到执行，也会造成死锁。

这种问题是由于 setnx 和 expire 是两条指令，而不是原子指令，如果两条指令可以一起执行就不会出现问题。我们很容易就可以想到用 Redis 的事务来解决，但是这里却不可以，因为，expire 是依赖于 setnx 的执行结果的，如果 setnx 没有抢到锁，expire 是不应该执行的，事务里没有 if-else 分支逻辑，事务的特点是一口气执行，要么全部执行，要么一个都不执行。

为了解决这个疑难，Redis 开源社区涌现了一堆分布式锁的 library，专门用来解决这个问题。为了解决这个疑难，Redis 开源社区涌现了一堆分布式锁的library，专门用来解决这个问题。如果你需要使用分布式锁，意味着你不能仅仅使用 Jedis 就行了，还得引入分布式锁的 library（读者可自行百度）。

在 Redis 2.8 中加入了 set 指令的扩展参数，使得 setnx 和 expire 指令可以一起执行，彻底解决了分布式锁的乱象

> set lock true ex 5 nx
ok 
> // 其他指令
> del lock

这个指令就是 setnx 和 expire 组合在一起的原子指令，它就是分布式锁的奥义所在。

超时问题

Redis 的分布式锁不能解决超时问题，如果在加锁和释放锁之间的逻辑执行的太长，以至于超出了锁的超时限制，就会出现问题。因为这时候锁过期了，第二个线程重新持有了这把锁，但是紧接着第一个线程执行完了业务逻辑，就把锁给释放了，第三个线程就会在第二个线程逻辑执行完之间拿到了锁。

为了避免这个问题，Redis 分布式锁不要用于较长时间的任务。

可重入性

可重入性是指线程在持有锁的情况下再次请求加锁，如果一个锁支持同一个线程的多次加锁，那么这个锁就是可重入的。比如 Java 语言里有个 ReentrantLock 就是可重入锁。Redis 分布式锁如果要支持可重入，需要对客户端的 set 方法进行包装，使用线程的 Threadlocal 变量存储当前持有锁的计数。

public class RedisWithReentrantLock {

    private ThreadLocal<Map<String, Integer>> lockers = new ThreadLocal<>();
    private Jedis jedis;
    private RedisWithReentrantLock(Jedis jedis) {
        this.jedis = jedis;
    }
	
    // 加锁
    private boolean lock(String key) {
        return jedis.set(key, "", "nx", "ex", 5L) != null;
    }
	
    // 释放锁
    private void unlock(String key) {
        jedis.del(key);
    }

    private Map<String, Integer> currentLockers() {
        Map<String, Integer> refs = lockers.get();
        if (refs != null) {
            return refs;
        }
        lockers.set(new HashMap<>());
        return lockers.get();
    }

    // 获取一个锁
    public boolean toLock(String key) {
        Map<String, Integer> refs = currentLockers();
        Integer refCnt = refs.get(key);
        if (refCnt != null) {
            refs.put(key, refCnt + 1);
            return true;
        }

        boolean ok = this.lock(key);
        if (!ok) {
            return false;
        }
        refs.put(key, 1);
        return true;
    }

    // 释放一个锁
    public boolean toUnlock(String key) {
        Map<String, Integer> refs = currentLockers();
        Integer refCnt = refs.get(key);
        if (refCnt == null) {
            return false;
        }
        refCnt -= 1;
        if (refCnt > 0) {
            refs.put(key, refCnt);
        } else {
            refs.remove(key);
            this.unlock(key);
        }
        return true;
    }
    
    public static void main(String[] args) {
        Jedis jedis = new Jedis();
        RedisWithReentrantLock redis = new RedisWithReentrantLock(jedis);

        redis.toLock("getLock");
        redis.toLock("getLock");
        redis.unlock("getLock");
        redis.unlock("getLock");
    }
}

关于分布式锁的全部内容，可以参考《Redis深度历险：核心原理和应用实践》，本文只是一个小小的摘要。