Redis提供的分布式锁有多个，这篇笔记主要记录redissonLock的相关内容
是什么
redissonLock的加锁思想：
- 在加锁的时候，只能指定加锁时长，不能指定等待时间，这是redissonLock和redLock的一个区别点，需要注意
- 如果没有指定leaseTime（加锁时长），默认会加30S，每10S进行一次锁续期
- 如果指定了leaseTime，那不会自动续期，到了leaseTime之后，如果依旧没有执行完毕，会释放锁，此时，其他线程就可以继续对key加锁
- 如果线程A加锁成功，线程B又来加锁，此时线程B会获取到线程A还有多少秒释放锁，然后线程B会通过semaphore信号量来等待一定的时间
- 线程B在等待了一定的时间之后，会重新尝试进行加锁，加锁成功，就返回，如果失败，就重复第4步
加锁源码解析
一、这是加锁的最外层判断
/**
* 这里是加锁的逻辑
* leaseTime是加锁时长
*/
private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
long threadId = Thread.currentThread().getId();
// 1.尝试加锁，如果加锁成功，返回的是nil，如果加锁失败，会返回当前key对应的锁失效时间
Long ttl = tryAcquire(leaseTime, unit, threadId);
// lock acquired 如果等于null，就表示加锁成功，return即可
if (ttl == null) {
return;
}
// 2.加锁失败，订阅对应的channel：channelName = redisson_lock__channel + 加锁的key
// 这里订阅，是Redis中提供的功能，具体的细节没有看
RFuture<RedissonLockEntry> future = subscribe(threadId);
// 这里的interruptibly是调用方法的时候入参进来的,这里应该是阻塞，具体没搞懂
if (interruptibly) {
commandExecutor.syncSubscriptionInterrupted(future);
} else {
commandExecutor.syncSubscription(future);
}
// 这里是一个死循环，除非当前线程加锁成功，直接break
try {
while (true) {
// 3.这里是进行一次加锁，如果线程加锁成功，就中断死循环，取消订阅，并返回
ttl = tryAcquire(leaseTime, unit, threadId);
// lock acquired
if (ttl == null) {
break;
}
// waiting for message
if (ttl >= 0) {
try {
// 4.这里是在依旧加锁失败的时候，进行await，这里可以点进去看下，实际调用的是semaphore的方法，初始化的信号量为0
// 也就是说，tryAcquire会阻塞等待
future.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
if (interruptibly) {
throw e;
}
future.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
}
} else {
// 5.这里else的场景，暂时没有想到是哪种场景下会进入到这里,有可能返回的是加锁的key的过期时间 -1？
if (interruptibly) {
future.getNow().getLatch().acquire();
} else {
future.getNow().getLatch().acquireUninterruptibly();
}
}
}
} finally {
// 6.在finally中会取消订阅，如果是线程自己尝试加锁成功了，就会取消订阅;
// 在锁被释放的时候，会发消息，通知对应的channelName，可以进行加锁了；在订阅者监听到锁被释放的消息之后，会唤醒对应的线程去加锁
unsubscribe(future, threadId);
}
}
二、下面来看加锁的核心逻辑
// 这里是尝试加锁的代码
private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, long threadId) {
// 1.如果指定了超时时间，就进入下面这个分支执行加锁的逻辑
if (leaseTime != -1) {
return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
}
// 2.如果没有指定超时时间，会进入到这里，默认加锁30S
RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
if (e != null) {
return;
}
// lock acquired
// 3.在加锁成功之后，会开启一个线程，在第10S的时候，进行锁续期
if (ttlRemaining == null) {
scheduleExpirationRenewal(threadId);
}
});
return ttlRemainingFuture;
}
上面的代码可以看到：
- 如果指定了加锁时长，就会进入最上面的if逻辑
- 如果没有指定加锁时长，会默认加30S，加完锁之后，会进入到onComplete()方法，这个方法就是锁续期的逻辑
这也是为什么自己指定了加锁时长之后，不会自动进行锁续期的原因
三、最底层加锁的lua脚本
// 这里就是真正加锁的lua脚本了
<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
internalLockLeaseTime = unit.toMillis(leaseTime);
return 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));
}
Redis分布式锁，底层采用的是hash结构
key是加锁的值，也就是在调用lock()方法时，指定的key
field是根据当前加锁的线程ID生成的一个值
value是重入次数
我觉得这段代码，是分布式锁的核心所在，为什么说分布式锁会比setnx要优秀，我觉得这段代码是很关键的一部分原因，通过lua脚本实现
这段lua脚本大致的思想是这样的：
- 先判断key是否存在，如果key不存在，就加锁，并且设置过期时间
- 如果key已经存在，并且当前加锁的key是重入了，那就将key对应的加锁次数加1
- 如果key已存在，并且当前加锁的key和线程和已加锁的不一样，无法重入，那就返回当前key的过期时间
四、锁续期
续期的代码是从 org.redisson.RedissonLock#scheduleExpirationRenewal 这个方法调用过来的
private void renewExpiration() {
ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
if (ee == null) {
return;
}
// 锁续期的核心代码，就是下面这个run方法
Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
@Override
public void run(Timeout timeout) throws Exception {
ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
if (ent == null) {
return;
}
Long threadId = ent.getFirstThreadId();
if (threadId == null) {
return;
}
// 上面应该都是一些判断，最终会调用下面这个代码，这里的lua脚本就是续期的
RFuture<Boolean> future = renewExpirationAsync(threadId);
future.onComplete((res, e) -> {
if (e != null) {
log.error("Can't update lock " + getName() + " expiration", e);
return;
}
// 如果续期成功，会循环调用
if (res) {
// reschedule itself
renewExpiration();
}
});
}
// internalLockLeaseTime 这个参数是加锁的时间，默认是30S，这里的意思是，会延迟 30 / 3的时间去执行run方法
}, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
ee.setTimeout(task);
}
所以：在续期的时候，会在有效期的三分之一时间时，进行续期，续期成功之后，会再次调用
下面是续期的lua脚本
protected RFuture<Boolean> renewExpirationAsync(long threadId) {
return evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return 1; " +
"end; " +
"return 0;",
Collections.singletonList(getName()),
internalLockLeaseTime, getLockName(threadId));
}
释放锁
org.redisson.RedissonLock#unlock
org.redisson.RedissonLock#unlockAsync(long)
org.redisson.RedissonLock#unlockInnerAsync
// 这是解锁的lua脚本
protected RFuture<Boolean> unlockInnerAsync(long threadId) {
return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
// 1.如果key为0，就直接发布一个锁释放的消息
"if (redis.call('exists', KEYS[1]) == 0) then " +
"redis.call('publish', KEYS[2], ARGV[1]); " +
"return 1; " +
"end;" +
// 2.如果key + 线程id对应的value为0，表示当前线程所加的锁已经被释放，return即可
"if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
"return nil;" +
"end; " +
// 3.如果上面条件都不满足，就将key + threadId对应的value - 1
"local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
// 3.1 如果-1之后，依旧大于0，表示重入了，重新设置超时时间即可
"if (counter > 0) then " +
"redis.call('pexpire', KEYS[1], ARGV[2]); " +
"return 0; " +
// 3.2 否则，表示当前key + threadId已经释放完毕
"else " +
"redis.call('del', KEYS[1]); " +
"redis.call('publish', KEYS[2], ARGV[1]); " +
"return 1; "+
"end; " +
"return nil;",
Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));
}
在解锁的时候，也有几种场景
1.key、field对应的value为0，表示锁已经释放，return nil即可
2.如果不等于0，就减1，如果减1之后的count依旧大于0，表示是锁重入，还有锁未释放，此时将锁实现时间重新设置为指定的阈值(如果没有指定，默认为30S)
3.如果减1之后的值为0，就del即可，然后发布消息，在对应的channel中，发布个unlock消息
这里所说的channel，就是前面加锁时，其他线程在加锁失败之后，所订阅的消息
总结
所以，redissonLock就是这个逻辑，没有waitTime的概念，线程B加锁的时候，如果线程A已经加锁，就会循环一致等待重试
5856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
