Redisson源码学习之RedissonFairLock

博客待整理，先只是把源码看了....
后面不再备注redis中的命令含义了，这样备注写太多了不好阅读.

package org.redisson;

import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;

import org.redisson.api.RFuture;
import org.redisson.api.RLock;
import org.redisson.client.codec.LongCodec;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.RedisStrictCommand;
import org.redisson.command.CommandExecutor;
import org.redisson.pubsub.LockPubSub;

/**
 * Distributed implementation of {@link java.util.concurrent.locks.Lock}
 * Implements reentrant lock.

 * Lock will be removed automatically if client disconnects.
 * 

 * Implements a fair locking so it guarantees an acquire order by threads.
 *
 * @author Nikita Koksharov
 *
 */
/** vergilyn mark: 

 * remove stale threads: 为什么不写成公共的? 

 * redisson是如何解决服务器之间时间不同步的: 因为{Redisson.UUID}, 不同服务器生成UUID不同, 所以其时间戳的值肯定会来至原有的服务器. 

 * "redisson_lock_queue:{lock_name}": 这LIST的顺序就是获取锁的顺序, 即FairLock实现原理. 

 * "redisson_lock_timeout:{xxx}": 这其中的score并不表示获取锁的顺序, 而是表示线程竞争锁的失效时间点. 

 */
public class RedissonFairLock extends RedissonLock implements RLock {

    private final long threadWaitTime = 5000;
    private final CommandExecutor commandExecutor;

    /** vergilyn mark: 

     *  构造函数, 被protected修饰, 说明不能在外部通过new获取; 一般的构建是:{@link Redisson#getFairLock(String)}. 

     * @param name lock的'锁名', 实际定义在{@link RedissonObject#name}
     * @param id
     */
    protected RedissonFairLock(CommandExecutor commandExecutor, String name, UUID id) {
        super(commandExecutor, name, id);
        this.commandExecutor = commandExecutor;
    }

    /** vergilyn mark: 

     * 未被修饰符修饰, 默认即friendly: 在同一个包中的类可以访问, 其他包中的类不能访问. 

     * type : LIST 

     * key  : "redisson_lock_queue:{lock_name}" 

     * value: "{Redisson.UUID}:{threadId}" 

     * @return ex, redisson_lock_queue:{lock_name}
     */
    String getThreadsQueueName() {
        return prefixName("redisson_lock_queue", getName());
    }

    /** vergilyn mark: 

     * type : SORT-SET 

     * key  : "redisson_lock_timeout:{lock_name}" 

     * value: "{Redisson.UUID}:{threadId}" 

     * score: 时间戳 

     * @return  ex, redisson_lock_timeout:{lock_name}
     */
    String getTimeoutSetName() {
        return prefixName("redisson_lock_timeout", getName());
    }
    
    @Override
    protected RedissonLockEntry getEntry(long threadId) {
        return PUBSUB.getEntry(getEntryName() + ":" + threadId);
    }

    /** vergilyn mark: 

     * 订阅, 重写: {@link RedissonLock#subscribe(long)}
     */
    @Override
    protected RFuture subscribe(long threadId) {
        return PUBSUB.subscribe(getEntryName() + ":" + threadId, 
                getChannelName() + ":" + getLockName(threadId), commandExecutor.getConnectionManager());
    }

    /** vergilyn mark: 

     * 取消订阅, 重写: {@link RedissonLock#unsubscribe(RFuture, long)}
     */
    @Override
    protected void unsubscribe(RFuture future, long threadId) {
        PUBSUB.unsubscribe(future.getNow(), getEntryName() + ":" + threadId, 
                getChannelName() + ":" + getLockName(threadId), commandExecutor.getConnectionManager());
    }

    @Override
    protected RFuture acquireFailedAsync(long threadId) {
        /* vergilyn mark: lua中数组下标是从1开始
         * lindex key index                   : LIST, 返回列表中下标为指定索引值的元素. 如果指定索引值不在列表的区间范围内, 返回 nil.
         * zrange key start stop [WITHSCORES] : SORT-SET, 通过索引区间返回有序集合成指定区间内的成员.
         * zincrby key increment member       : SORT-SET, 有序集合中对指定成员的分数加上增量 increment.
         * zrem key member [member ...]       : SORT-SET, 移除有序集合中的一个或多个成员
         * lrem key count value               : LIST, 移除列表元素(count=0, 表示全部)
         */
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_VOID,
                    // KEYS[1]: "redisson_lock_queue:{xxx}",   ARGV[1]: "{Redisson.UUID}:{threadId}"
                    // KEYS[2]: "redisson_lock_timeout:{xxx}", ARGV[2]: "{threadWaitTime}"(默认: 5000ms)
                    "local firstThreadId = redis.call('lindex', KEYS[1], 0); " +
                    "if firstThreadId == ARGV[1] then " +
                        "local keys = redis.call('zrange', KEYS[2], 0, -1); " + 
                        "for i = 1, #keys, 1 do " + 
                            "redis.call('zincrby', KEYS[2], -tonumber(ARGV[2]), keys[i]);" + 
                        "end;" + 
                    "end;" +
                    "redis.call('zrem', KEYS[2], ARGV[1]); " +
                    "redis.call('lrem', KEYS[1], 0, ARGV[1]); ",
                    Arrays.