Config config = new Config();
		config.useSingleServer().setAddress("redis://127.0.0.1:6379");

		RedissonClient redisson = Redisson.create(config);
		RLock lock = redisson.getLock("MyLock");

		lock.lock();

    //name：鎖的名稱(chēng)
    public RLock getLock(String name) {
    //默認(rèn)創(chuàng)建的同步執(zhí)行器, (存在異步執(zhí)行器, 因?yàn)殒i的獲取和釋放是有強(qiáng)一致性要求, 默認(rèn)同步)
        return new RedissonLock(this.connectionManager.getCommandExecutor(), name);
    }

    public RedissonLock(CommandAsyncExecutor commandExecutor, String name) {
        super(commandExecutor, name);
        this.commandExecutor = commandExecutor;
       
        //唯一ID
        this.id = commandExecutor.getConnectionManager().getId();
        //等待獲取鎖時(shí)間
        this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();
        //ID + 鎖名稱(chēng)
        this.entryName = this.id + ":" + name;
        //發(fā)布訂閱
        this.pubSub = commandExecutor.getConnectionManager().getSubscribeService().getLockPubSub();
    }

public class Config {
	
	private long lockWatchdogTimeout = 30 * 1000;
		
	public long getLockWatchdogTimeout() {
		return lockWatchdogTimeout;
	}
	
	//省略
}

    public void lock() {
        try {
            this.lock(-1L, (TimeUnit)null, false);
        } catch (InterruptedException var2) {
            throw new IllegalStateException();
        }
    }

    private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
        long threadId = Thread.currentThread().getId();
        Long ttl = this.tryAcquire(leaseTime, unit, threadId);
        if (ttl != null) {
            RFuture<RedissonLockEntry> future = this.subscribe(threadId);
            if (interruptibly) {
                this.commandExecutor.syncSubscriptionInterrupted(future);
            } else {
                this.commandExecutor.syncSubscription(future);
            }

    private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, long threadId) {
      //執(zhí)行 tryLock(...) 才會(huì)進(jìn)入
        if (leaseTime != -1L) {
        //進(jìn)行異步獲取鎖
            return this.tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
        } else {
         //嘗試異步獲取鎖, 獲取鎖成功返回空, 否則返回鎖剩余過(guò)期時(shí)間
            RFuture<Long> ttlRemainingFuture = this.tryLockInnerAsync(this.commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
            
         //ttlRemainingFuture 執(zhí)行完成后觸發(fā)此操作
            ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
                if (e == null) {
                //ttlRemaining == null 代表獲取了鎖
                //獲取到鎖后執(zhí)行續(xù)時(shí)操作
                    if (ttlRemaining == null) {
                        this.scheduleExpirationRenewal(threadId);
                    }

                }
            });
            return ttlRemainingFuture;
        }
    }

    private void scheduleExpirationRenewal(long threadId) {
        RedissonLock.ExpirationEntry entry = new RedissonLock.ExpirationEntry();
        RedissonLock.ExpirationEntry oldEntry = (RedissonLock.ExpirationEntry)EXPIRATION_RENEWAL_MAP.putIfAbsent(this.getEntryName(), entry);
        if (oldEntry != null) {
            oldEntry.addThreadId(threadId);
        } else {
            entry.addThreadId(threadId);
            this.renewExpiration();
        }

    }

    private void renewExpiration() {
     //從容器中去獲取要被續(xù)期的鎖
        RedissonLock.ExpirationEntry ee = (RedissonLock.ExpirationEntry)EXPIRATION_RENEWAL_MAP.get(this.getEntryName());
         //容器中沒(méi)有要續(xù)期的鎖，直接返回null
        if (ee != null) {
        //創(chuàng)建定時(shí)任務(wù)
        //并且執(zhí)行的時(shí)間為 30000/3 毫秒，也就是 10 秒后
            Timeout task = this.commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
                public void run(Timeout timeout) throws Exception {
                //從容器中取出線程
                    RedissonLock.ExpirationEntry ent = (RedissonLock.ExpirationEntry)RedissonLock.EXPIRATION_RENEWAL_MAP.get(RedissonLock.this.getEntryName());
                    if (ent != null) {
                   
                        Long threadId = ent.getFirstThreadId();
                        if (threadId != null) {
                        //Redis進(jìn)行鎖續(xù)期
                    //這個(gè)方法的作用其實(shí)底層也是去執(zhí)行LUA腳本
                            RFuture<Boolean> future = RedissonLock.this.renewExpirationAsync(threadId);
                            //同理去處理Redis續(xù)命結(jié)果
                            future.onComplete((res, e) -> {
                                if (e != null) {
                                    RedissonLock.log.error("Can't update lock " + RedissonLock.this.getName() + " expiration", e);
                                } else {
                                 //如果成功續(xù)期，遞歸繼續(xù)創(chuàng)建下一個(gè) 10S 后的任務(wù)
                                    if (res) {
                                    //遞歸繼續(xù)創(chuàng)建下一個(gè)10S后的任務(wù)
                                        RedissonLock.this.renewExpiration();
                                    }

                                }
                            });
                        }
                    }
                }
            }, this.internalLockLeaseTime / 3L, TimeUnit.MILLISECONDS);
            ee.setTimeout(task);
        }
    }