Redisson锁是我们常用的分布式锁，其核心方法就是获取锁对象（getLock）、加锁（lock、tryLock）和释放锁（unlock），下面从锁的初始化、加锁和释放锁三部分分析Redisson锁的原理。

一、初始化

这里我们一般使用Redisson的getLock方法获取RLock锁对象

public RLock getLock(String name) {
    return new RedissonLock(connectionManager.getCommandExecutor(), name);
}
1
2
3

在getLock方法中新建了一个RedissonLock对象，其源码是

public RedissonLock(CommandAsyncExecutor commandExecutor, String name) {
    // 父类的构造方法，最终是RedissonObject
    super(commandExecutor, name);
    // 初始化命令执行器
    this.commandExecutor = commandExecutor;
    // 初始化id，用于锁的前缀
    this.id = commandExecutor.getConnectionManager().getId();
    // 初始化锁的默认时间，这里采用的是看门狗的时间，默认30s
    this.internalLockLeaseTime = commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout();
    // 锁的标识
    this.entryName = id + ":" + name;
    // 初始化锁的监听器，用于在锁被占用时，使用Redis的pub/sub功能订阅锁释放消息
    this.pubSub = commandExecutor.getConnectionManager().getSubscribeService().getLockPubSub();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

二、加锁

加锁有lock和tryLock两类方法，区别在于tryLock方法会有一个等待时间，如果超过等待时间未获取到锁就会返回false，表示获取锁失败，而lock方法会一直等待，直到获取到锁，两者的源码相差不大，这里主要分析tryLock方法的源码。
源码分析如下：

@Override
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
    long time = unit.toMillis(waitTime);
    long current = System.currentTimeMillis();
    // 获取当前线程id
    long threadId = Thread.currentThread().getId();
    // 获取锁，底层实现是lua脚本，具体参考下面的tryAcquireAsync源码（这部分包括lua脚本加锁和加锁时间续期）
    Long ttl = tryAcquire(leaseTime, unit, threadId);
    // 锁获取成功，返回true
    if (ttl == null) {
        return true;
    }

    // 后面是锁获取失败的处理流程
     
 
    time -= System.currentTimeMillis() - current;
    // 等待时间用完，获取锁失败
    if (time <= 0) {
        acquireFailed(threadId);
        return false;
    }
     
    current = System.currentTimeMillis();
    // 订阅锁释放的通知
    RFuture<RedissonLockEntry> subscribeFuture = subscribe(threadId);
    // 剩余时间内未订阅成功
    if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) {
        // 尝试取消订阅过程，若无法取消，则会取消订阅
        if (!subscribeFuture.cancel(false)) {
            subscribeFuture.onComplete((res, e) -> {
                if (e == null) {
                    unsubscribe(subscribeFuture, threadId);
                }
            });
        }
        // 获取锁失败
        acquireFailed(threadId);
        return false;
    }

    try {
        time -= System.currentTimeMillis() - current;
        // 等待时间用完，加锁失败
        if (time <= 0) {
            acquireFailed(threadId);
            return false;
        }
     
        // 自旋获取锁
        while (true) {
            // 尝试获取锁
            long currentTime = System.currentTimeMillis();
            ttl = tryAcquire(leaseTime, unit, threadId);
            // 获取成功
            if (ttl == null) {
                return true;
            }
             
            // 未获取成功，若等待时间用完，则加锁失败
            time -= System.currentTimeMillis() - currentTime;
            if (time <= 0) {
                acquireFailed(threadId);
                return false;
            }

            // 通过java.util.concurrent包的Semaphore（信号量）挂起线程等待锁释放
            currentTime = System.currentTimeMillis();
            if (ttl >= 0 && ttl < time) {
                getEntry(threadId).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {
                getEntry(threadId).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
            }
             
            // 等待时间已用完，获取锁失败
            time -= System.currentTimeMillis() - currentTime;
            if (time <= 0) {
                acquireFailed(threadId);
                return false;
            }
        }
    } finally {
        // 取消订阅锁释放
        unsubscribe(subscribeFuture, threadId);
    }
//        return get(tryLockAsync(waitTime, leaseTime, unit));
}
private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, long threadId) {
    //  指定加锁时间
    if (leaseTime != -1) {
        // lua脚本加锁，详细见tryLockInnerAsync源码
        return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    }
    // 未指定加锁时间，则异步执行尝试获取锁，加锁时间是默认的30s
    RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
        if (e != null) {
            return;
        }
 
        // 获取锁成功，开启时间轮任务，用于锁续期
        if (ttlRemaining == null) {
            scheduleExpirationRenewal(threadId);
        }
    });
     
    return ttlRemainingFuture;
}
 
private void scheduleExpirationRenewal(long threadId) {
    ExpirationEntry entry = new ExpirationEntry();
    // 获取当前线程的锁续期任务节点
    ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
    if (oldEntry != null) {
        // 若当前线程的锁续期任务任务节点已存在，将节点计数加1
        oldEntry.addThreadId(threadId);
    } else {
        // 不存在，说明是新的线程获取锁
        // 将节点计数加1
        entry.addThreadId(threadId);
        // 开始时间轮调度任务
        // 其会每10s执行一次调度任务，给锁续期
        renewExpiration();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

这里可以看到在不指定锁的过期时间时，Redisson会自动给锁续期，这可以解决业务未执行完锁就释放的问题，但同时也有缺点，若系统出现异常，锁未执行到finally的unlock，就会造成死锁，其他的线程将无法再获取到该锁。在日常编码中，我们更偏向于指定锁的过期时间，保证在异常情况下锁也能够被释放，至于业务未执行完锁就释放的问题，通过合理评估业务耗时，合理设置过期时间即可。
锁每次重入都会将锁续期任务节点的计数加1，是为了在释放锁的时候判断释放几次后将锁续期任务停止。
下面看一下锁存入redis的lua脚本：

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);
    // KEYS[1]为 Collections.