//通过getLock获取RLock对象，进行加锁 
RLock lock = redissonClient.getLock("serviceKey");

lock.lock();

//getLock源码 
@Override public RLock getLock(String name) { 
　　return new RedissonLock(connectionManager.getCommandExecutor(), name); 
}

public RedissonLock(CommandAsyncExecutor commandExecutor, String name) { 
    super(commandExecutor, name); 
    //命令执行器，封装了redis的链接，用于操作redis的命令 
    this.commandExecutor = commandExecutor; 
    this.id = commandExecutor.getConnectionManager().getId(); 
    //看门狗续期时间（重点） 
    this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(); 
    this.entryName = id + ":" + name; 
}

public class Config { 
 
     ...... 
    //看门狗默认续期时间是30s 
    private long lockWatchdogTimeout = 30 * 1000; 
 
}

public class RedissonLock extends RedissonExpirable implements RLock{ 
    @Override 
    public void lock() { 
        try { 
            //参数1.续期时间 
            //参数2.时间单位 
            //参数3.加锁过程是否允许中断 
            lock(-1, null, false); 
        } catch (InterruptedException e) { 
            throw new IllegalStateException(); 
        } 
    } 
 
    @Override 
    public void lock(long leaseTime, TimeUnit unit) { 
        try { 
            lock(leaseTime, unit, false); 
        } catch (InterruptedException e) { 
            throw new IllegalStateException(); 
        } 
    } 
}

    //如果不存在加锁的key(serviceKey)就执行加锁的逻辑 
"if (redis.call('exists', KEYS[1]) == 0) then " + 
    //hincrby命令：给指定Hash类型Key对应的Map结构的，key对应的value值进行+1 
    "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
    //pexpire命令:给指定的Key设置过期时间 
    "redis.call('pexpire', KEYS[1], ARGV[1]); " + 
    "return nil; " + 
    "end; " + 
    //判断Hash类型的加锁的key对应的的Map结构中，key对应的value是否存在 
"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " + 
    //将key对应的value值进行+1 
    "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
    //pexpire命令:给指定的Key设置过期时间 
    "redis.call('pexpire', KEYS[1], ARGV[1]); " + 
     "return nil; " + 
     "end; " + 
    //返回Key(serviceKey)的过期时间 
"return redis.call('pttl', KEYS[1]);",

evalWriteAsync(getName(), LongCodec.INSTANCE, command, 
                "if (redis.call('exists', KEYS[1]) == 0) then " + 
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " + 
                        "return nil; " + 
                        "end; " + 
                        "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " + 
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + 
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " + 
                        "return nil; " + 
                        "end; " + 
                        "return redis.call('pttl', KEYS[1]);", 
                Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId)); 
    }

    @Override 
    public <T, R> RFuture<R> evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params) { 
        NodeSource source = getNodeSource(key); 
        return evalAsync(source, false, codec, evalCommandType, script, keys, params); 
    }

    private NodeSource getNodeSource(String key) { 
        //计算当前Key所在槽的值 
        //如果是cluster模式，则使用crc16算法计算 
        //如果是主从模式，则使用固定的槽的值 
        int slot = connectionManager.calcSlot(key); 
        //通过计算得到的槽的值，获取到当前加锁的Redis节点实例信息 
        MasterSlaveEntry entry = connectionManager.getEntry(slot); 
        return new NodeSource(entry, slot); 
    }

    @Override 
    public int calcSlot(String key) { 
        if (key == null) { 
            return 0; 
        } 
 
        int start = key.indexOf('{'); 
        if (start != -1) { 
            int end = key.indexOf('}'); 
            key = key.substring(start+1, end); 
        } 
        //MAX_SLOT =16384  
        //将Key，CRC16计算出来的值 对16384取模 
        int result = CRC16.crc16(key.getBytes()) % MAX_SLOT; 
        log.debug("slot {} for {}", result, key); 
        return result; 
    }