redisson锁相关源码

1、redisson加锁源码理解

​   redisson先获取RLock对象，调用lock、tryLock方法来完成加锁的功能

​   lock方法是直接加锁，如果锁已被占用，则直接线程阻塞，进行等待，直到锁被占用方释放。

  tryLock方法则是设定了waitTime（等待时间），在这个等待时间没到前，也是线程阻塞并反复去获取锁，直到取到锁或等待时间超时，则返回false

2、加锁

   1、LOCK加锁

/**
 * 加锁操作 （设置锁的有效时间）
 * @param lockName 锁名称
 * @param leaseTime  锁有效时间
 */
public void lock(String lockName, long leaseTime) {
    RLock rLock = redisson.getLock(lockName);
    rLock.lock(leaseTime, TimeUnit.SECONDS);
}

  这一步主要分为了俩种方式，第一种是外部传递进来了锁的释放时间，第二种是直接一定在等待（-1）锁的释放时间

@Override
public void lock(long leaseTime, TimeUnit unit) {
    try {
        lockInterruptibly(leaseTime, unit);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

@Override
public void lockInterruptibly() throws InterruptedException {
    lockInterruptibly(-1, null);
}

 @Override
public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException {
	//获取当前线程ID
    long threadId = Thread.currentThread().getId();
    //去获取锁，如果没有获取到这个ttl是等于空，如果没有获取到锁这个TTL就是这个锁还有多长时间
    Long ttl = tryAcquire(leaseTime, unit, threadId);
    // lock acquired
    if (ttl == null) {
    	//加锁成功
         return;
    }

	//这是开始订阅事件，比如现在另外一个线程进来，但是发现锁已经被前面的线程已经获取到了，那么当前线程通过 Redis 的 channel 订阅锁释放的事件
    RFuture future = subscribe(threadId);
    //命令模式进行同步订阅事件
    commandExecutor.syncSubscription(future);

    try {
    	//进入死循环，等待获取锁的进程并不是通过一个 while(true) 死循环去获取锁，而是利用了 Redis 的发布订阅机制,通过 await 方法阻塞等待锁的进程，有效的解决了无效的锁申请浪费资源的问题 （Semaphore）
        while (true) {
        	//重新去获取锁
           ttl = tryAcquire(leaseTime, unit, threadId);
           // lock acquired
           if (ttl == null) {
	           //加锁成功
               break;
           }

            // waiting for message
            //阻塞等待锁（通过信号量(共享锁)阻塞,等待解锁消息）当锁释放并发布释放锁的消息后，
            信号量的 release() 方法会被调用，此时被信号量阻塞的等待队列中的一个线程就可以继续尝试获取锁了
            if (ttl >= 0) {
            	//如果TTL>=0 则重新去信号量重试去获取信息
                 getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {
            	 //如果小于0则进行等待获取信息
                  getEntry(threadId).getLatch().acquire();
            }
         }
    } finally {
    	//无论是否获得锁,都要取消订阅解锁消息
         unsubscribe(future, threadId);
    }
//     get(lockAsync(leaseTime, unit));
    }

//获取锁的逻辑其实就是通过一段lua脚本实现
 RFuture tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);

    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
              "if (redis.call('exists', KEYS[1]) == 0) then " +
                  "redis.call('hset', 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.