vlambda博客
学习文章列表

源码分析:Redisson 分布式锁过程分析

封面图来自:Redisson性能压测权威发布 http://www.redis.cn/articles/20170704108.html

一 摘要

    Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象,还提供了许多分布式服务。

    通常使用最为广泛的就是它提供的基于Redis的分布式锁功能。本篇也集中对Redisson的分布式锁实现进行分析。

   使用的Redisson版本为3.12.2,maven引入依赖信息:

<dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.12.2</version></dependency>

二 锁过程源码

如下代码所示,是我们适用Redisson获取和释放分布式锁的一个demo:

RedissonClient redisson = Redisson.create();RLock lock = redisson.getLock("anyLock");lock.lock();// 其他代码....lock.unlock();

其中,Redisson.create();是默认的创建方法,内容为:

public static RedissonClient create() { Config config = new Config(); ((SingleServerConfig)config.useSingleServer().setTimeout(1000000)).setAddress("redis://127.0.0.1:6379"); return create(config);}

可见,这里使用了本地的redis集群,和默认的6379端口。

   这里重点分析加锁过程,也就是lock.lock(); 方法部分,来看Redisson是怎样实现加锁,以及可能得锁续期等watchdog的动作,下面是RedissonLock类中的lock()方法:

public void lock() { try { this.lock(-1L, (TimeUnit)null, false); } catch (InterruptedException var2) { throw new IllegalStateException(); }}

这里继续向下调用了一个含参数的lock()方法,设置了释放时间(默认设置了-1),TimeUnit(null),是否可中断(false),我们继续看这个方法:

private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException { long threadId = Thread.currentThread().getId(); Long ttl = this.tryAcquire(leaseTime, unit, threadId); if (ttl != null) { RFuture<RedissonLockEntry> future = this.subscribe(threadId); if (interruptibly) { this.commandExecutor.syncSubscriptionInterrupted(future); } else { this.commandExecutor.syncSubscription(future); } try { while(true) { ttl = this.tryAcquire(leaseTime, unit, threadId); if (ttl == null) { return; } if (ttl >= 0L) { try { ((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } catch (InterruptedException var13) { if (interruptibly) { throw var13; } ((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } } else if (interruptibly) { ((RedissonLockEntry)future.getNow()).getLatch().acquire(); } else { ((RedissonLockEntry)future.getNow()).getLatch().acquireUninterruptibly(); } } } finally { this.unsubscribe(future, threadId); } }}

这一部分代码较长,我们按照步骤整理一下:

1、获取当前线程的线程id;

2、tryAquire尝试获取锁,并返回ttl

3、如果ttl为空,则结束流程;否则进入后续逻辑;

4、this.subscribe(threadId)订阅当前线程,返回一个RFuture;

5、下一步涉及是否可中断标记的判断,如果可中断,调用

 
   
   
 
this.commandExecutor.syncSubscriptionInterrupted(future);

否则,调用:

 
   
   
 
this.commandExecutor.syncSubscription(future);

6、通过while(true)循环,一直尝试获取锁:ttl = this.tryAcquire(leaseTime, unit, threadId);

中止条件:1)ttl == null;2)如果ttl>=0,((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);

这个过程中,会判断iterruptibly,为true时会处理中断

7、fially代码块,会解除订阅

 
   
   
 
this.unsubscribe(future, threadId);

三 详细分析



redisson watchdog 使用和原理这篇文章整理了一张加锁流程图,我们引用如下:

下面详细分析Redisson获取锁、锁等待、释放锁的详细实现过程。

3.1 获取锁

3.1.1 核心获取锁的方法-tryLockInnerAsync

 <T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) { this.internalLockLeaseTime = unit.toMillis(leaseTime); return this.commandExecutor.evalWriteAsync(this.getName(), LongCodec.INSTANCE, command, "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]);", Collections.singletonList(this.getName()), new Object[]{this.internalLockLeaseTime, this.getLockName(threadId)});}


 
   
   
 
第二行的代码很长,我们对文本做一些换行处理:
return this.commandExecutor.evalWriteAsync(this.getName(), LongCodec.INSTANCE, command,"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]);",Collections.singletonList(this.getName()), new Object[]{this.internalLockLeaseTime, this.getLockName(threadId)});

这样就比较容易看出,重点是一系列的redis命令。分析如下:

RedissonLock类tryLockInnerAsync通过eval命令执行Lua代码完成加锁操作。KEYS[1]为锁在redis中的key,key对应value为map结构,ARGV[1]为锁超时时间,ARGV[2]为锁value中的key。ARGV[2]由UUID+threadId组成,用来标记锁被谁持有。

1)第一个If判断key是否存在,不存在则完成加锁操作

redis.call('hset', KEYS[1], ARGV[2], 1);创建key[1] map中添加key:ARGV[2] ,value:1;

redis.call('pexpire', KEYS[1], ARGV[1]);设置key[1]过期时间,避免发生死锁。eval命令执行Lua代码的时候,Lua代码将被当成一个命令去执行,并且直到eval命令执行完成,Redis才会执行其他命令。可避免第一条命令执行成功第二条命令执行失败导致死锁。

2)第二个if判断key存在且当前线程已经持有锁, 重入:

redis.call('hexists', KEYS[1], ARGV[2]);判断redis中锁的标记值是否与当前请求的标记值相同,相同代表该线程已经获取锁;

redis.call('hincrby', KEYS[1], ARGV[2], 1);记录同一线程持有锁之后累计加锁次数,实现锁重入;

redis.call('pexpire', KEYS[1], ARGV[1]); 重置锁超时时间。

(3)key存在被其他线程获取的锁, 等待:

redis.call('pttl', KEYS[1]);   加锁失败返回锁过期时间。



其中pexpire语句的重置锁超时时间,实际上就是Redisson的watch dog机制

3.1.2 commandExecutor.evalWriteAsync

   继续向下,commandExecutor.evalWriteAsync:

public <T, R> RFuture<R> evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params) { NodeSource source = this.getNodeSource(key); return this.evalAsync(source, false, codec, evalCommandType, script, keys, params);}
 

3.1.3 syncSubscriptionInterrupted


public void syncSubscriptionInterrupted(RFuture<?> future) throws InterruptedException { MasterSlaveServersConfig config = this.connectionManager.getConfig(); int timeout = config.getTimeout() + config.getRetryInterval() * config.getRetryAttempts(); if (!future.await((long)timeout)) { ((RPromise)future).tryFailure(new RedisTimeoutException("Subscribe timeout: (" + timeout + "ms). Increase 'subscriptionsPerConnection' and/or 'subscriptionConnectionPoolSize' parameters.")); } future.sync();}
 

关于超时时间的计算,使用的是config中的Timeout时间+重试周期x重试次数;当RFuture等待超时时,就会使用tryFailure抛出RedisTimeoutException的异常信息,提示订阅失败。

3.2 锁等待 lockInterruptibly

public void lockInterruptibly(long leaseTime, TimeUnit unit) throws InterruptedException { this.lock(leaseTime, unit, true); } private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException { long threadId = Thread.currentThread().getId(); Long ttl = this.tryAcquire(leaseTime, unit, threadId); if (ttl != null) { RFuture<RedissonLockEntry> future = this.subscribe(threadId); if (interruptibly) { this.commandExecutor.syncSubscriptionInterrupted(future); } else { this.commandExecutor.syncSubscription(future); } try { while(true) { ttl = this.tryAcquire(leaseTime, unit, threadId); if (ttl == null) { return; } if (ttl >= 0L) { try { ((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } catch (InterruptedException var13) { if (interruptibly) { throw var13; } ((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } } else if (interruptibly) { ((RedissonLockEntry)future.getNow()).getLatch().acquire(); } else { ((RedissonLockEntry)future.getNow()).getLatch().acquireUninterruptibly(); } } } finally { this.unsubscribe(future, threadId); } } }

这段代码也很长,简单总结如下:

(1)步骤一:调用加锁操作;

(2)步骤二:步骤一中加锁操作失败,订阅消息,利用redis的pubsub提供一个通知机制来减少不断的重试,避免发生活锁。

注:

活锁:是指线程1可以使用资源,但它很礼貌,让其他线程先使用资源,线程2也可以使用资源,但它很绅士,也让其他线程先使用资源。这样你让我,我让你,最后两个线程都无法使用资源。

(3)步骤三:

getLath()获取RedissionLockEntry实例latch变量,由于permits为0,所以调用acquire()方法后线程阻塞。



3.3 释放锁 - unlockInnerAsync

protected RFuture<Boolean> unlockInnerAsync(long threadId) { return this.commandExecutor.evalWriteAsync(this.getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN, "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;", Arrays.asList(this.getName(), this.getChannelName()), new Object[]{LockPubSub.UNLOCK_MESSAGE, this.internalLockLeaseTime, this.getLockName(threadId)});}

   与获取锁代码类似,还是一个比较长的redis命令,我们把redis命令格式化整理后如下:

if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) thenreturn 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;

(1)第一个if判断锁对应key存在,value中是否存在当前要释放锁的标示,不存在返回nil,确保锁只能被持有的线程释放;

(2)对应key存在,value中存在当前要释放锁的标示,将锁标示对应值-1,第二个if判断锁标示对应的值是否大于0,大于0,表示有锁重入情况发生,重新设置锁过期时间;

(3)对应key存在,value中存在当前要释放锁的标示,将锁标示对应值-1后等于0,调用del操作释放锁,并publish消息,将获取锁被阻塞的线程恢复重新获取锁;

这里的代码中,涉及了一个重要的类:LockPubSub,下面是释放时执行的release()方法:

订阅者接收到publish消息后,执行release操作,调用acquire被阻塞的线程将继续执行获取锁操作。

3.4 其他-CommandSyncService

   在命令执行时,我们可以看到Redisson是通过this.commandExecutor执行的,而这个是在 Redisson的构造方法中做的初始化:

protected Redisson(Config config) { this.config = config; Config configCopy = new Config(config); this.connectionManager = ConfigSupport.createConnectionManager(configCopy); this.evictionScheduler = new EvictionScheduler(this.connectionManager.getCommandExecutor()); this.writeBehindService = new WriteBehindService(this.connectionManager.getCommandExecutor());}


 

四 Redisson与Jedis分布式锁实现对比

   在某业务中,使用的是基于Jedis封装得分布式锁操作工具,虽然并非是Jedis提供的标准实现,但从中可以了解一下分布式锁的不同实现:

4.1 获取锁

下面是某业务封装jedis获取分布式锁和释放的工具:

public static boolean tryGetDistributedLock(JedisPool jedisPool, String lockKey, String requestId, int expireTime) throws RedisToolException { Jedis jedis = null; boolean var6; try { jedis = jedisPool.getResource(); String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime); var6 = "OK".equals(result); } catch (Throwable var10) { throw new RedisToolException(var10.getMessage()); } finally { if (jedis != null) { jedis.close(); } } return var6;}


 

继续向下,查看jedis.set方法:

public String set(String key, String value, String nxxx, String expx, int time) { this.checkIsInMultiOrPipeline(); this.client.set(key, value, nxxx, expx, time); return this.client.getStatusCodeReply();}


 
   
   
 
可见,同样是为了 保证设置锁key 和 设置超时时间两个动作的原子性,Redisson是使用lua脚本,而Jedis是通过Redis提供的set命令。 早期必须lua脚本来实现,是因为redis旧版本没有提供这个新的set命令,不支持一个命令中同时设置key和超时时间。



4.2 释放锁

public static boolean releaseDistributedLock(JedisPool jedisPool, String lockKey, String requestId) { String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"; Jedis jedis = null; boolean var6; try { jedis = jedisPool.getResource(); Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId)); var6 = RELEASE_SUCCESS.equals(result); } finally { if (jedis != null) { jedis.close(); } } return var6;}

   Jedis在释放锁的时候,还是通过脚本来实现的判断和删除key,保证操作的原子性。

4.3 锁续期支持

4.3.1 Redisson的watch dog

   Redisson提供了订阅和watch dog机制,当业务线程还在执行锁超时时,如果开启了watch dog,那么可以实现自动续期。但事实上,这个机制比较耗费资源,所以一般不建议开启,除非业务确实有较强的这方面需求。

   官方文档对watch dog的描述:

 
   
   
 
lockWatchdogTimeout(监控锁的看门狗超时,单位:毫秒)
默认值:30000
监控锁的看门狗超时时间单位为毫秒。该参数只适用于分布式锁的加锁请求中未明确使用leaseTimeout参数的情况。
如果该看门狗未使用lockWatchdogTimeout去重新调整一个分布式锁的lockWatchdogTimeout超时,那么这个锁
将变为失效状态。这个参数可以用来避免由Redisson客户端节点宕机或其他原因造成死锁的情况。

4.3.2 基于Jedis实现

   除了tryGetDistributedLock之外,还提供了一种过期时间怕短的锁方法,当锁即将超时时,会抛出超时异常,这样业务在捕获异常后,可以选择继续获取锁、或回滚事务并释放锁等动作,把主动权交给业务方。示例代码如下:

public static void lock(JedisPool jedisPool, String lockKey, String requestId, int expireTime, int timeout) throws Exception { if (timeout > expireTime) { throw new Exception("timeout 必须大于 expireTime"); } else { Random random = new Random(); while(timeout > 0) { boolean lock = tryGetDistributedLock(jedisPool, lockKey, requestId, expireTime); if (lock) { return; } int applyTime = random.nextInt(100); timeout -= applyTime; Thread.sleep((long)applyTime); } throw new LockTimeOutException("distributedLock timeout"); }}


 

五 总结

   本文基于Redisson3.12.2版本源码,对Redisson分布式锁过程进行了分析。从获取锁、释放锁的过程,可以大概了解Redisson的主要设计思想。此外,还对基于Jedis实现的一个分布式锁示例与Redisson进行对比,来看基于Redis的分布式锁的两种不同实现方式。