Redisson分布式锁学习总结：读锁 RedissonReadLock#lock 获取锁源码分析

1、RReadWriteLock 使用&读写锁介绍

首先，我们先简单上个简单使用 RReadWriteLock 的 demo：

public class RedissonReadWriteLockDemo {

    public static void main(String[] args) {
        RedissonClient client = RedissonClientUtil.getClient("");
        RReadWriteLock readWriteLock = client.getReadWriteLock("myLock");
        RLock readLock = readWriteLock.readLock();
        RLock writeLock = readWriteLock.writeLock();

        // 场景一：先读锁，后写锁
        readLock.lock();
        writeLock.lock();
        readLock.unlock();
        writeLock.unlock();

        // 场景二：重复获取读锁
        readLock.lock();
        readLock.lock();
        readLock.unlock();
        readLock.unlock();

        // 场景三：先写锁，后读锁
        writeLock.lock();
        readLock.lock();
        writeLock.unlock();
        readLock.lock();

        // 场景四：先写锁，再读锁
        writeLock.lock();
        writeLock.lock();
        writeLock.unlock();
        writeLock.unlock();
    }
}

读写锁作用：

• 读读兼容
• 读写互斥
• 写写互斥
• 写读互斥

使用场景： 读写锁主要作用就是做到保证数据的一致性。例如有人在读数据的时候，就应该避免数据被修改，从而保证数据读取前后的一致性，其他的情况一样，例如写读，写写；但是如果是读读就没有必要做到互斥了，因为此时数据不会被修改，多少个人过来读都是一样的，不会影响到数据的一致性。

但是，在平时开发中，读写锁是基本用不上的，因为MySQL自带的 MVCC 机制和锁机制就能保证了数据的原子性、一致性、隔离性和持久性。也就是我们说的ACID。而我们普通的程序或者系统，无非就是对数据库的表数据进行增删改查。

如果我们在程序中自己维护了一套元数据，例如map集合，并且我们的程序是分布式系统，那么就可以利用Redisson提供的分布式读写锁来保证元数据的一致性了。

那么下面我们将分析 redisson 提供的 RReadWriteLock 读写锁是如何做到分布式读写控制的，并且证实一下 RReadWriteLock 提供的作用是否和上面所说的一致，还是说会有点出入。

2、RReadWriteLock 和 RedissonLock 的关系

从上面文章我们也知道，Redisson 提供的公平锁是基于 RedissonLock 做的扩展；但其实不但是公平锁，Redisson 提供的读写锁也是基于 RedissonLcok 上做的扩展：

所以接下来，我们只需要分析读锁和写锁的加锁逻辑和释放锁逻辑；但还有读锁的 wathcdog lua 脚本也是要分析的。因为读锁 watchdog 机制虽然和 RedissonLock 保持的是一致的，但是执行的 lua 脚本的方法却是重写过的。

3、RedissonReadLock 之 lua 脚本加锁

RedissonReadLock#tryLockInnerAsync：

@Override
<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);

    return evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                            "local mode = redis.call('hget', KEYS[1], 'mode'); " +
                            "if (mode == false) then " +
                              "redis.call('hset', KEYS[1], 'mode', 'read'); " +
                              "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                              "redis.call('set', KEYS[2] .. ':1', 1); " +
                              "redis.call('pexpire', KEYS[2] .. ':1', ARGV[1]); " +
                              "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                              "return nil; " +
                            "end; " +
                            "if (mode == 'read') or (mode == 'write' and redis.call('hexists', KEYS[1], ARGV[3]) == 1) then " +
                              "local ind = redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
                              "local key = KEYS[2] .. ':' .. ind;" +
                              "redis.call('set', key, 1); " +
                              "redis.call('pexpire', key, ARGV[1]); " +
                              "local remainTime = redis.call('pttl', KEYS[1]); " +
                              "redis.call('pexpire', KEYS[1], math.max(remainTime, ARGV[1])); " +
                              "return nil; " +
                            "end;" +
                            "return redis.call('pttl', KEYS[1]);",
                    Arrays.<Object>asList(getName(), getReadWriteTimeoutNamePrefix(threadId)), 
                    internalLockLeaseTime, getLockName(threadId), getWriteLockName(threadId));
}

lua 脚本不长，我们一步一步分析。

3.1、KEYS

Arrays.