Redis添加分布式锁

https://blog.csdn.net/weixin_51146329/article/details/129612350 看门狗

1.不是高并发的场景

stringRedisTemplate.opsForValue().setIfAbsent("zql","人在代码在",10,TimeUnit.SECONDS);//只加过期限制

2.高并发的场景

如果加锁的过期时间小于业务执行时间，那么需要给每个线程的锁加这个线程的唯一标识，让每个线程的锁只能自己释放。

String clientId = UUID.randomUUID().tostring();

Boolean result = stringRedisTemplate.opsForValue.setIfAbsent("zql",clientId,10,TimeUnit.SECONDS);

if(!result){

return "error";

}

if(clientId.equals(stringRedisTemplate.opsForValue().get(zql))){

//释放锁

}

3.在2的基础上实现一个定时重置过期时间的功能。--锁续命--看门狗

redisson实现：

 

redisson会在一个线程开启锁之后开启一个分线程，这个线程每过三分之一超时时间，重新set超时时间。

 

1. 看门狗机制概述
看门狗机制是Redission提供的一种自动延期机制，这个机制使得Redission提供的分布式锁是可以自动续期的。

private long lockWatchdogTimeout = 30 * 1000;
1
看门狗机制提供的默认超时时间是30*1000毫秒，也就是30秒

如果一个线程获取锁后，运行程序到释放锁所花费的时间大于锁自动释放时间（也就是看门狗机制提供的超时时间30s），那么Redission会自动给redis中的目标锁延长超时时间。

在Redission中想要启动看门狗机制，那么我们就不用获取锁的时候自己定义leaseTime(锁自动释放时间)。

如果自己定义了锁自动释放时间的话，无论是通过lock还是tryLock方法，都无法启用看门狗机制。

但是，如果传入的leaseTime为-1，也是会开启看门狗机制的。

分布式锁是不能设置永不过期的，这是为了避免在分布式的情况下，一个节点获取锁之后宕机从而出现死锁的情况，所以需要个分布式锁设置一个过期时间。但是这样会导致一个线程拿到锁后，在锁的过期时间到达的时候程序还没运行完，导致锁超时释放了，那么其他线程就能获取锁进来，从而出现问题。

所以，看门狗机制的自动续期，就很好地解决了这一个问题。

2. 源码解读
进入tryLock方法，这里的tryLock(waitTime, -1, unit)有三个参数

waitTime：获取锁的最大等待时间（没有传默认为-1）
leaseTime：锁自动释放的时间（没有传的话默认-1）
unit：时间的单位（等待时间和锁自动释放的时间单位）
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().getLatch().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));
}
这上面一坨主要是锁重试的代码，