Redis系列-生产应用篇-分布式锁（4）-单进程Redis分布式锁的Java实现（Redisson使用与底层实现）-读写锁

Redisson单进程Redis分布式悲观锁的使用与实现

本文基于Redisson 3.7.5

3. 读写锁

Redisson的分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。同时还支持自动过期解锁。该对象允许同时有多个读取锁，但是最多只能有一个写锁。写锁是排它锁，获取写锁的时候不能有已经获取读锁和写锁的，获取写锁后，除了本线程以外没发获取读写锁。

RReadWriteLock rwlock = redisson.getLock("testLock");
// 最常见的使用方法
rwlock.readLock().lock();
// 或
rwlock.writeLock().lock();

// 支持过期解锁功能
// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// 或
rwlock.writeLock().lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// 或
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();

查看redisson.getLock("testLock");的源码：

@Override
public RReadWriteLock getReadWriteLock(String name) {
    return new RedissonReadWriteLock(connectionManager.getCommandExecutor(), name);
}

可以看出读写锁的实现类是RReadWriteLock，查看RReadWriteLock的源码：

public class RedissonReadWriteLock extends RedissonExpirable implements RReadWriteLock {
    public RedissonReadWriteLock(CommandAsyncExecutor commandExecutor, String name) {
        super(commandExecutor, name);
    }
    /**
     * @return 读锁
     */
    @Override
    public RLock readLock() {
        return new RedissonReadLock(commandExecutor, getName());
    }
    /**
     * @return 写锁
     */
    @Override
    public RLock writeLock() {
        return new RedissonWriteLock(commandExecutor, getName());
    }
}

3.1. 读写锁实现思路

首先说一下读写锁的特性：

场景1

1. 线程A获取了读锁
2. 线程B尝试获取读锁，获取成功
3. 线程C尝试获取写锁，获取失败

场景2

1. 线程A获取了写锁
2. 线程B尝试获取读锁，获取失败
3. 线程C尝试获取写锁，获取失败

场景3
1. 线程A获取了读锁
2. 线程A尝试获取写锁，获取失败

场景4
1. 线程A获取了写锁
2. 线程A尝试获取读锁，获取成功

场景5
1. 线程A获取了写锁
2. 线程A再次尝试获取写锁，获取成功
3. 线程A尝试获取读锁，获取成功
4. 线程A再次尝试获取读锁，获取成功
5. 线程A释放读锁，线程A还是持有读锁
6. 线程A释放写锁，线程A还是持有写锁
7. 线程A释放写锁，线程A不再持有写锁
8. 线程B尝试获取读锁，获取成功

设计的基于Redis实现的分布式读写锁，需要满足以上五个场景。
看一下在Redis中，读写锁的分布是：

3.2. 读写锁源码分析

3.2.1. 读锁源码

public class RedissonReadLock extends RedissonLock implements RLock {

    public RedissonReadLock(CommandAsyncExecutor commandExecutor, String name) {
        super(commandExecutor, name);
    }

    @Override
    String getChannelName() {
        return prefixName("redisson_rwlock", getName());
    }

    String getWriteLockName(long threadId) {
        return super.getLockName(threadId) + ":write";
    }

    String getReadWriteTimeoutNamePrefix(long threadId) {
        return suffixName(getName(), getLockName(threadId)) + ":rwlock_timeout";
    }

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

        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                                //获取当前锁的mode的value
                                "local mode = redis.call('hget', KEYS[1], 'mode'); " +
                                //如果mode不存在，证明锁还没被占用，直接获取锁
                                "if (mode == false) then " +
                                  //设置HASH的mode为read
                                  "redis.call('hset', KEYS[1], 'mode', 'read'); " +
                                  //设置HASH的threadId对应的LockName的value为1（这个1代表重入次数），相当于该thread获取到了锁
                                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                                  //设置threadId对应的tReadWriteTimeoutName末尾连着获取锁次数（因为现在是第一次所以是1）这个key为1
                                  "redis.call('set', KEYS[2] .. ':1', 1); " +
                                  //设置两个key的过期时间为锁过期时间
                                  "redis.call('pexpire', KEYS[2] .. ':1', ARGV[1]); " +
                                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                                  "return nil; " +
                                "end; " +
                                //如果mode已存在，是read（代表是读锁），或者是write并且获取这个锁的就是本线程
                                "if (mode == 'read') or (mode == 'write' and redis.call('hexists', KEYS[1], ARGV[3]) == 1) then " +
                                  //使HASH的threadId对应的LockName的value+1，代表重入锁获取次数加一
                                  "local ind = redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                                  //同时设置threadId对应的tReadWriteTimeoutName末尾连着获取锁次数为1
                                  "local key = KEYS[2] .. ':' .. ind;" +
                                  "redis.call('set', key, 1); " +
                                  //刷新以上两个key的过期时间
                                  "redis.call('pexpire', key, ARGV[1]); " +
                                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                                  "return nil; " +
                                "end;" +
                                "return redis.call('pttl', KEYS[1]);",
                        Arrays.