Redisson的看门狗机制
自动续期问题：当一个程序的运行程序及释放锁的时间大于锁的自动释放时间，那么我们就需要一种自动续期的机制。
Redisson的看门狗机制主要是用来解决锁自动续期问题。
看门狗机制有一个重要的参数，那就是看门狗续期时间leaseTime(锁自动释放时间)（默认为30s），如果我们需要在Redisson里面开启看门狗机制，那么我们就不用获取锁的时候自己定义leaseTime(锁自动释放时间)。
而如果我们自定义了锁释放时间，无论为trylock方法还是lock方法都无法开启看门狗机制，但是当我们设置leaseTime为-1的时候，也可以开启看门狗机制。
看门狗的源码剖析
首先从tryLock方法里面着手：
这里面有三个参数：
- 获取锁的最大等待时间（没有传默认为-1）
- 看门狗续期时间（没有传的时候默认为-1）
- 时间单位
public boolean tryLock(long waitTime, TimeUnit unit) throws InterruptedException {
return tryLock(waitTime, -1, unit);
}
@Override
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
long time = unit.toMillis(waitTime);
long current = System.currentTimeMillis();
long threadId = Thread.currentThread().getId();
Long ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
// lock acquired
if (ttl == null) {
return true;
}
time -= System.currentTimeMillis() - current;
if (time <= 0) {
acquireFailed(waitTime, unit, 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(waitTime, unit, threadId);
return false;
}
try {
time -= System.currentTimeMillis() - current;
if (time <= 0) {
acquireFailed(waitTime, unit, threadId);
return false;
}
while (true) {
long currentTime = System.currentTimeMillis();
ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
// lock acquired
if (ttl == null) {
return true;
}
time -= System.currentTimeMillis() - currentTime;
if (time <= 0) {
acquireFailed(waitTime, unit, threadId);
return false;
}
// waiting for message
currentTime = System.currentTimeMillis();
if (ttl >= 0 && ttl < time) {
subscribeFuture.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
} else {
subscribeFuture.getNow().get门闩().tryAcquire(time, TimeUnit.MILLISECONDS);
}
time -= System.currentTimeMillis() - currentTime;
if (time <= 0) {
acquireFailed(waitTime, unit, threadId);
return false;
}
}
} finally {
unsubscribe(subscribeFuture, threadId);
}
// return get(tryLockAsync(waitTime, leaseTime, unit));
}
而看门狗机制的主要代码就是在于这个 tryAcquire(waitTime, leaseTime, unit, threadId)方法上面
我们可以看看 tryAcquire(waitTime, leaseTime, unit, threadId)方法的源码
private Long tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
return get(tryAcquireAsync(waitTime, leaseTime, unit, threadId));
}
private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
if (leaseTime != -1L) {
//leaseTime不等于-1就说明没有启动看门狗机制，正常执行获取锁的操作
return this.tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
} else {
//如果获取锁失败，返回的结果是这个key的剩余有效期
//使用异步调用下面的函数
RFuture<Long> ttlRemainingFuture =
this.tryLockInnerAsync(waitTime, /*这个是锁重试时间 */ this.commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(),/*这个是看门狗等待时间 */
TimeUnit.MILLISECONDS,/*这个是时间单位 */
threadId, /*这个是线程id */
RedisCommands.EVAL_LONG /*执行lua脚本的命令 */
);
//上面获取锁回调成功之后，执行这代码块的内容
ttlRemainingFuture.onComplete((ttlRemaining, e) -> {
//不存在异常
if (e == null) {
//剩余有效期为null
if (ttlRemaining == null) {
//这个函数是解决最长等待有效期的问题
this.scheduleExpirationRenewal(threadId);
}
}
});
return ttlRemainingFuture;
}
}
//这个方法如果获取到了锁就返回null，如果没有获取到锁就返回这个key的剩余时间
<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
internalLockLeaseTime = unit.toMillis(leaseTime);
//这个代码就是使用lua脚本来实现可重入锁的逻辑
1.锁不存在：创建锁并设置过期时间
2.锁已存在且由当前线程持有：增加重入次数并更新过期时间
3.锁已存在但由其他线程持有：返回剩余过期时间
return evalWriteAsync(getName(), LongCodec.INSTANCE, command,
// 锁不存在，则往redis中设置锁信息
"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));
}
接着我们可以看scheduleExpirationRenewal(threadId)这个方法的源码
一个锁就对应自己的一个ExpirationEntry类，
EXPIRATION_RENEWAL_MAP存放的是所有的所信息。
根据锁的名称从EXPIRATION_RENEWAL_MAP里面获取锁，如果存在这把锁则重入，如果不存在，则将这个新锁放置进EXPIRATION_RENEWAL_MAP，并且开启看门狗机制。
private static final ConcurrentMap<String, ExpirationEntry> EXPIRATION_RENEWAL_MAP = new ConcurrentHashMap<>();
private void scheduleExpirationRenewal(long threadId) {
ExpirationEntry entry = new ExpirationEntry();
//这里EntryName是指锁的名称
ExpirationEntry oldEntry = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.putIfAbsent(this.getEntryName(), entry);
if (oldEntry != null) {
//重入
//将线程ID加入
oldEntry.addThreadId(threadId);
} else {
//将线程ID加入
entry.addThreadId(threadId);
//续约
this.renewExpiration();
}
}
最重要的代码就是里面的续约代码————renewExpiration()
private void renewExpiration() {
//先从map里得到这个ExpirationEntry
ExpirationEntry ee = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.get(this.getEntryName());
if (ee != null) {
//这个是一个延迟任务
Timeout task = this.commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
//延迟任务内容
public void run(Timeout timeout) throws Exception {
//拿出ExpirationEntry
ExpirationEntry ent = (ExpirationEntry)RedissonLock.EXPIRATION_RENEWAL_MAP.get(RedissonLock.this.getEntryName());
if (ent != null) {
//从ExpirationEntry拿出线程ID
Long threadId = ent.getFirstThreadId();
if (threadId != null) {
//调用renewExpirationAsync方法刷新最长等待时间
RFuture<Boolean> future = RedissonLock.this.renewExpirationAsync(threadId);
future.onComplete((res, e) -> {
if (e != null) {
RedissonLock.log.error("Can't update lock " + RedissonLock.this.getName() + " expiration", e);
} else {
if (res) {
//renewExpirationAsync方法执行成功之后，进行递归调用，调用自己本身函数
//那么就可以实现这样的效果
//首先第一次进行这个函数，设置了一个延迟任务，在10s后执行
//10s后，执行延迟任务的内容，刷新有效期成功，那么就会再新建一个延迟任务，刷新最长等待有效期
//这样这个最长等待时间就会一直续费
RedissonLock.this.renewExpiration();
}
}
});
}
}
}
},
//这是锁自动释放时间，因为没传，所以是看门狗时间=30*1000
//也就是10s
this.internalLockLeaseTime / 3L,
//时间单位
TimeUnit.MILLISECONDS);
//给当前ExpirationEntry设置延迟任务
ee.setTimeout(task);
}
}
// 刷新等待时间
protected RFuture<Boolean> renewExpirationAsync(long threadId) {
//使用lua脚本来刷新等待时间
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));
}
续约的流程如下
- 如果是第一次续约，我们会设置一个延迟任务，这个延迟任务会在1/3的看门狗时间进行
- 到了1/3的看门狗时间后，我们会执行一个延迟任务
- 首先我们会调用renewExpirationAsync方法刷新最长等待时间
- 如果刷新成功，那么我们会递归调用自己（renewExpiration()）来实现无限续期
最后的释放锁的代码
public RFuture<Void> unlockAsync(long threadId) {
RPromise<Void> result = new RedissonPromise();
RFuture<Boolean> future = this.unlockInnerAsync(threadId);
future.onComplete((opStatus, e) -> {
//取消锁更新任务
this.cancelExpirationRenewal(threadId);
if (e != null) {
result.tryFailure(e);
} else if (opStatus == null) {
IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: " + this.id + " thread-id: " + threadId);
result.tryFailure(cause);
} else {
result.trySuccess((Object)null);
}
});
return result;
}
void cancelExpirationRenewal(Long threadId) {
//获得当前这把锁的任务
ExpirationEntry task = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.get(this.getEntryName());
if (task != null) {
//当前锁的延迟任务不为空，且线程id不为空
if (threadId != null) {
//先把线程ID去掉
task.removeThreadId(threadId);
}
if (threadId == null || task.hasNoThreads()) {
//然后取出延迟任务
Timeout timeout = task.getTimeout();
if (timeout != null) {
//把延迟任务取消掉
timeout.cancel();
}
//再把ExpirationEntry移除出map
EXPIRATION_RENEWAL_MAP.remove(this.getEntryName());
}
}
}
Redsson的看门狗机制总结
- 首先开启看门狗机制的首要条件是leaseTime=-1（leaseTime默认就是-1）
- 首先通过tryLockInnerAsync方法获取锁
- 如果获取到了锁，那就开始执行scheduleExpirationRenewal(threadId)方法，即开始执行看门狗机制
- 当线程第一次获取到锁（也就是不是重入的情况），那么就会调用renewExpiration方法开启看门狗机制
- renewExpiration方法首先会创建一个延迟任务执行，延迟时间为10s，执行任务就是通过lua脚本来刷新最长等待时间
- 并且在任务最后还会继续递归调用renewExpiration。（这样就可以实现不断续约）
- 在释放锁的时候就会将锁对应的线程ID移除，并从锁中把延迟队伍取出，取消。并把在将这把锁从
EXPIRATION_RENEWAL_MAP中移除。
总的流程就是：首先获取到锁（这个锁30s后自动释放），然后对锁设置一个延迟任务（10s后执行），延迟任务给锁的释放时间刷新为30s，并且还为锁再设置一个相同的延迟任务（10s后执行），这样就达到了如果一直不释放锁（程序没有执行完）的话，看门狗机制会每10s将锁的自动释放时间刷新为30s。
posted on
浙公网安备 33010602011771号