redisson实现分布式锁的原理
1. 原理
2. 源码中加锁的lua代码
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]);
为什么要使用lua语言因为一大堆复杂的业务逻辑,可以通过封装在lua脚本中发送给redis,保证这段复杂业务逻辑执行的原子性
lua字段解释KEYS[1]:表示你加锁的那个key,比如说
RLock lock = redisson.getLock(“myLock”);
这里的key就是“myLock”。ARGV[1]:表示锁的有效期,默认30sARGV[2]:表示hash结构的FIELD,格式客户端id:申请锁的线程id
,如:8743c9c0-0795-4907-87fd-6c719a6b4586:63
3. 加锁机制
lua中第一个if判断语句,就是用“exists myLock”命令判断一下,如果你要加锁的那个锁key不存在的话,就进行加锁。如何加锁呢?很简单,用下面的hset命令:
hset myLock 8743c9c0-0795-4907-87fd-6c719a6b4586:63 1
此时的myLock锁key的数据结构是:
myLock:{ 8743c9c0-0795-4907-87fd-6c719a6b4586:63 1}
接着会执行“pexpire myLock 30000”命令,设置myLock这个锁key的生存时间是30秒(默认)
4. 锁互斥机制 + 自旋机制
如果在这个时候,另一个客户端(客户端2)来尝试加锁,执行了同样的一段lua脚本,会怎样呢?
第一个if判断会执行“exists myLock”,发现myLock这个锁key已经存在了。
接着第二个if判断会执行“hexists mylock 客户端id”,来判断myLock锁key的hash数据结构中,是否包含客户端2的ID,但是明显不是的,因为那里包含的是客户端1的ID。
所以,客户端2会获取到pttl myLock返回的一个数字,这个数字代表了myLock这个锁key的剩余生存时间。
比如还剩15000毫秒的生存时间。此时客户端2会进入一个while循环,不停的尝试加锁。
5. 可重入加锁机制
如果客户端1已经持有这把锁,可重入的加锁会怎么样呢
// 重入加锁RLock lock = redisson.getLock("myLock")lock.lock();// 业务代码lock.lock();// 业务代码lock.unlock();lock.unlock();
分析上面lua代码第一个if判断不成立,“exists myLock” 会显示锁key已经存在了
第二个if会成立,因为myLock的hash数据结构中包含的客户端1的ID,也就是“8743c9c0-0795-4907-87fd-6c719a6b4586:1”
此时就会执行可重入加锁的逻辑,用hincrby这个命令,对客户端1的加锁次数,累加1:
hincrby myLock 8743c9c0-0795-4907-87fd-6c71a6b4586:63 1
此时myLock数据结构变为下面这样:
myLock: { 8743c9c0-0795-4907-87fd-6c719a6b4586:63 2 }
6. 释放锁机制
redisson释放锁的lua代码
if (redis.call('exists', KEYS[1]) == 0) then redis.call('publish', KEYS[2], ARGV[1]); return 1;end;if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then return nil;end;local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1);if (counter > 0) then redis.call('pexpire', KEYS[1], ARGV[2]); return 0;else redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1;end;return nil;
执行lock.unlock(),就可以释放分布式锁,此时的业务逻辑也是非常简单的。
就是每次都对myLock数据结构中的那个加锁次数减1。如果发现加锁次数是0了,说明这个客户端已经不再持有锁了,此时就会用:“del myLock”命令,从redis里删除这个key。
然后另外的客户端2就可以尝试完成加锁了。
7. watch dog自动延期机制
客户端1加锁的myLock默认生存时间才30秒,如果超过了30秒,客户端1还想一直持有这把锁,怎么办呢?
redisson中客户端1一旦加锁成功,就会启动一个watch dog看门狗,他是一个后台线程,会每隔10秒检查一下,如果客户端1还持有myLock,那么就会不断的延长myLock的生存时间。
如果负责存储这个分布式锁的redission节点宕机后,而且这个锁正好处于锁住的状态时,这个锁会出现锁死的状态,为了避免这种情况的发生,redisson提供了一个监控锁的看门狗,它的作用是在redisson实例被关闭前,不断的延长锁的有效期。默认情况下,看门狗的续期时间是30s,也可以通过修改Config.lockWatchdogTimeout来另行指定。
来看
org.redisson.config.Config
源码:public Config() { this.transportMode = TransportMode.NIO; // 看门狗的默认续期时间是30s this.lockWatchdogTimeout = 30000L; this.keepPubSubOrder = true; this.decodeInExecutor = false; this.useScriptCache = false; this.minCleanUpDelay = 5; this.maxCleanUpDelay = 1800; this.cleanUpKeysAmount = 100; this.nettyHook = new DefaultNettyHook(); this.useThreadClassLoader = true; this.addressResolverGroupFactory = new DnsAddressResolverGroupFactory();}
可以看到,这个加的分布式锁的超时时间默认是30秒.但是还有一个问题,那就是这个看门狗,多久来延长一次有效期呢?来看
org.redisson.RedissonLock
源码private void renewExpiration() { RedissonLock.ExpirationEntry ee = (RedissonLock.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 { RedissonLock.ExpirationEntry ent = (RedissonLock.ExpirationEntry)RedissonLock.EXPIRATION_RENEWAL_MAP.get(RedissonLock.this.getEntryName()); if (ent != null) { Long threadId = ent.getFirstThreadId(); if (threadId != null) { 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) { RedissonLock.this.renewExpiration(); } } }); } } } }, this.internalLockLeaseTime / 3L, TimeUnit.MILLISECONDS); ee.setTimeout(task); }}private void scheduleExpirationRenewal(long threadId) { RedissonLock.ExpirationEntry entry = new RedissonLock.ExpirationEntry(); RedissonLock.ExpirationEntry oldEntry = (RedissonLock.ExpirationEntry)EXPIRATION_RENEWAL_MAP.putIfAbsent(this.getEntryName(), entry); if (oldEntry != null) { oldEntry.addThreadId(threadId); } else { entry.addThreadId(threadId); this.renewExpiration(); }}
通过
org.redisson.RedissonLock#lock
可以看出,获取锁成功就会开启一个定时任务,也就是watchdog,定时任务会定期检查去续期(这里定时用的是netty-common包中的HashedWheelTimer)从
org.redisson.RedissonLock#renewExpiration
方法可以看出该定时调度每次调用的时间差是internalLockLeaseTime / 3。也就10秒.通过源码分析我们知道,默认情况下,加锁的时间是30秒.如果加锁的业务没有执行完,那么有效期到 30-10 = 20秒的时候,就会进行一次续期,把锁重置成30秒.那这个时候可能又有同学问了,那业务的机器万一宕机了呢?宕机了定时任务跑不了,就续不了期,那自然30秒之后锁就解开了呗.
另外redisson还提供了
lock(long leaseTime, TimeUnit unit)
可以指定加锁时间的方法。超过leaseTime
时间后锁便自动解开了。不会再对锁进行续期!!!
极端情况
如果你对某个redis master实例,写入了myLock这种锁key的value,此时会异步复制给对应的master slave实例。但是这个过程中一旦发生redis master宕机,主备切换,redis slave变为了redis master。接着就会导致,客户端2来尝试加锁的时候,在新的redis master上完成了加锁,而客户端1也以为自己成功加了锁。此时就会导致多个客户端对一个分布式锁完成了加锁。这时系统在业务上一定会出现问题,导致脏数据的产生。这个就是redis cluster,或者是redis master-slave架构的主从异步复制导致的redis分布式锁的最大缺陷:在redis master实例宕机的时候,可能导致多个客户端同时完成加锁。
结语
这就是所谓的分布式锁的开源redisson框架的实现机制。
一般我们在生产系统中,可以用redisson框架提供的这个类库来基于redis进行分布式锁的加锁与释放锁。
参考
Redission分布式锁原理