redisson 底层读写锁 lua实现原理

读锁

@Override
    <T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        return evalWriteAsync(getRawName(), 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); " +
                                        // 设置辅助键，后面的数字 1 表示读锁的次数
                                        // KEYS[2]是每个线程的标识符
                                  "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 " +
                                        //在锁的哈希表中将字段 ARGV[2] 的值增加1，表示当前线程持有该锁的次数。
                                  "local ind = redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                                        //索引 ind 标识了读锁的次数
                                  "local key = KEYS[2] .. ':' .. ind;" +
                                        //设置辅助键的值为 1，表示当前线程持有读锁
                                  "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(getRawName(), getReadWriteTimeoutNamePrefix(threadId)),
                        unit.toMillis(leaseTime), getLockName(threadId), getWriteLockName(threadId));
    }

在上面的代码中，辅助键可能有点让人难理解，下面我来解释一下:

KEYS[1] 表示锁的主要标识，通常是一个唯一的标识符，比如对象名字或资源名字，用来表示被锁定的资源。

KEYS[2] 通常用于记录哪些线程获取了该锁，每个线程的标识符会作为 KEYS[2] 的一部分，用于标识不同的线程。这个方式可以帮助跟踪锁的持有者，以及每个线程持有该锁的次数。

举个示例来说明，假设有一个对象名为 "myObject"，多个线程试图获取这个对象的锁。在这种情况下：

KEYS[1] 可能是 "myObject"，用于标识被锁定的对象。
KEYS[2] 可能包含多个不同的线程标识符，每个线程标识符都是 KEYS[2] 的一部分，用于表示不同的线程获取了该锁。
例如，线程 A 获取了 "myObject" 的锁，可能会生成一个键值对 "myObject:A:1"，表示线程 A 获取了该锁，并且是第一次获取。线程 B 获取了锁后，可能会生成一个键值对 "myObject:B:1"，以此类推。这样就可以跟踪每个线程获取锁的情况。

总之，KEYS[1] 用于标识被锁定的资源，KEYS[2] 通常用于记录锁的持有者和锁的状态，可以根据实际需求来设计和使用。

写锁

@Override
    <T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        return evalWriteAsync(getRawName(), LongCodec.INSTANCE, command,
                            "local mode = redis.call('hget', KEYS[1], 'mode'); " +
                            "if (mode == false) then " +
                                    // 说明锁不存在
                                  "redis.call('hset', KEYS[1], 'mode', 'write'); " +
                                    //持有锁的计数为1
                                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                                  "return nil; " +
                              "end; " +
                              "if (mode == 'write') then " +
                                    //判断当前线程 是否持有 写锁,若有走下面逻辑
                                  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                                    // 支持可重入锁
                                      "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                                    //获取当前锁的剩余过期时间
                                      "local currentExpire = redis.call('pttl', KEYS[1]); " +
                                    // 延长锁过期时间
                                      "redis.call('pexpire', KEYS[1], currentExpire + ARGV[1]); " +
                                      "return nil; " +
                                  "end; " +
                                "end;" +
                                    // 查询剩余过期时间
                                "return redis.call('pttl', KEYS[1]);",
                        Arrays.<Object>asList(getRawName()),
                        unit.toMillis(leaseTime), getLockName(threadId));
    }

写锁逻辑比较简单..