- 当前位置：首页 >IT科技类资讯 >Redisson 高性能 Redis 分布式锁源码分析
Redisson 高性能 Redis 分布式锁源码分析
发布时间：2025-11-05 05:59:05 来源：码上建站 作者：域名
Redisson 实现分布式锁的高性机制如下：
测试代码
下面我们将以一个秒杀的例子来说明：
依赖版本 复制implementation org.redisson:redisson-spring-boot-starter:3.17.01. 测试代码下面是模拟一个商品秒杀的场景，示例代码如下：
复制public class RedissonTest { public static void main(String[] args) { //1. 配置部分
Config config = new Config(); String address = "redis://127.0.0.1:6379"; SingleServerConfig serverConfig = config.useSingleServer(); serverConfig.setAddress(address); serverConfig.setDatabase(0); config.setLockWatchdogTimeout(5000); Redisson redisson = (Redisson) Redisson.create(config); RLock rLock = redisson.getLock("goods:1000:1"); //2. 加锁
rLock.lock(); try { System.out.println("todo 逻辑处理 1000000."); } finally { if (rLock.isLocked() && rLock.isHeldByCurrentThread()) { //3. 解锁
rLock.unlock(); } } }}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27. 加锁设计rLock.lock();是加锁的企商汇核心代码，我们一起来看看调用栈
加锁的核心方法是：org.redisson.RedissonLock#tryLockInnerAsync
复制<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) { return evalWriteAsync(getRawName(), 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(getRawName()), unit.toMillis(leaseTime), getLockName(threadId)); }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.其实它的本质是调用一段 LUA 脚本进行加锁， 需要注意的是这个地方使用的数据类型是 hash。这里是用 hash 的好处就是可以通过同一个 key 来存储重入的 tid
锁续期设计锁的续期是在 org.redisson.RedissonLock#tryAcquireAsync方法中调用 scheduleExpirationRenewal实现的。
续期需要注意的是，看门狗是设置在主线程的延迟队列的线程中。
这里的好处就是如果我在一个进程中，同时加了 1000 把锁，我们不需要启动 1000 个子线程去续期，只需要创建 1000 个续期任务对象即可，在到达续期时间才会唤醒续期线程。亿华云计算
tryAcquireAsync 代码如下：
复制private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) { RFuture<Long> ttlRemainingFuture; if (leaseTime != -1) { ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG); } else { ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime, TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG); } CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> { //lock acquired
if (ttlRemaining == null) { if (leaseTime != -1) { internalLockLeaseTime = unit.toMillis(leaseTime); } else { //锁过期时间续期
scheduleExpirationRenewal(threadId); } } return ttlRemaining; }); return new CompletableFutureWrapper<>(f);}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.锁续期 scheduleExpirationRenewal代码如下：
复制protected void scheduleExpirationRenewal(long threadId) { ExpirationEntry entry = new ExpirationEntry(); ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry); if (oldEntry != null) { oldEntry.addThreadId(threadId); } else { entry.addThreadId(threadId); try { renewExpiration(); } finally { if (Thread.currentThread().isInterrupted()) { cancelExpirationRenewal(threadId); } } }}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.然后在调用 renewExpiration(); 执行续期逻辑, 其实这里是一个定时任务 + 递归的方式实现续期的，用定时任务的好处就是不用去开 N 个字线程，只需要创建对应的任务对象即可。
备注：如果超级极端的情况下 N 把锁，同时加锁，同时需求。我们可以考虑在锁的有效期上，给它加一个浮动时间比如 100 - 500ms. 这样就能一定程度上避免 （参考的是缓存失效/击穿的解决方案）
复制private void renewExpiration() { ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName()); if (ee == null) { return; } //创建延迟任务
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.whenComplete((res, e) -> { if (e != null) { log.error("Cant update lock " + getRawName() + " expiration", e); EXPIRATION_RENEWAL_MAP.remove(getEntryName()); return; } //如果续期成功
if (res) { //reschedule itself
renewExpiration(); } else { cancelExpirationRenewal(null); } }); } }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS); ee.setTimeout(task);}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.这里还有一个小的点，就是续期的时间是 1/3 为什么呢？保证在下次续期的时候锁不过期，如果是 1/2 可能在下次定时任务执行的时候 key 已经过期，如果小于 1/3 会导致频繁续期，任务代价/收益比不高。
renewExpirationAsync方法, 里面还是亿华云一段 LUA 脚本，进行重新设置锁的过期时间。
复制 protected RFuture<Boolean> renewExpirationAsync(long threadId) { return evalWriteAsync(getRawName(), 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(getRawName()), internalLockLeaseTime, getLockName(threadId)); }1.2.3.4.5.6.7.8.9.10. 锁的自旋重试org.redisson.RedissonLock#lock(long, java.util.concurrent.TimeUnit, boolean)在执行获取锁失败的时候，会进入重试。其实这里就会执行 18 行以后的 while (true)逻辑
复制private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException { long threadId = Thread.currentThread().getId(); Long ttl = tryAcquire(-1, leaseTime, unit, threadId); //lock acquired
if (ttl == null) { return; } //订阅锁过期的消息
CompletableFuture<RedissonLockEntry> future = subscribe(threadId); RedissonLockEntry entry; if (interruptibly) { entry = commandExecutor.getInterrupted(future); } else { entry = commandExecutor.get(future); } try { while (true) { ttl = tryAcquire(-1, leaseTime, unit, threadId); //lock acquired
if (ttl == null) { break; } //waiting for message
if (ttl >= 0) { try { //阻塞锁的超时时间，等锁过期后再尝试加锁
entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { if (interruptibly) { throw e; } entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS); } } else { if (interruptibly) { entry.getLatch().acquire(); } else { entry.getLatch().acquireUninterruptibly(); } } } } finally { unsubscribe(entry, threadId); }// get(lockAsync(leaseTime, unit));}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.entry.getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);其实这里就是一个间歇性自旋。等到上次锁过期的时间，在唤醒进行抢锁 entry.getLatch().acquire();
订阅锁失效还有一个逻辑就是
CompletableFuture future = subscribe(threadId);
这里其实是会订阅一个消息，如果解锁过后，会发布解锁的消息。然后再唤醒当前多次竞争锁进入休眠的线程。
解锁设计rLock.unlock(); 的核心就是释放锁，撤销续期和唤醒在等待加锁的线程（发布解锁成功消息）。
核心方法（解锁）： org.redisson.RedissonLock#unlockInnerAsync
复制protected RFuture<Boolean> unlockInnerAsync(long threadId) { return evalWriteAsync(getRawName(), 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(getRawName(), getChannelName()), LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime, getLockName(threadId)); }1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.还是 LUA 的执行方式。
撤销锁续期核心方法 org.redisson.RedissonBaseLock#unlockAsync(long)
复制@Override
public RFuture<Void> unlockAsync(long threadId) { //解锁
RFuture<Boolean> future = unlockInnerAsync(threadId); //撤销续期
CompletionStage<Void> f = future.handle((opStatus, e) -> { cancelExpirationRenewal(threadId); if (e != null) { throw new CompletionException(e); } if (opStatus == null) { IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: " + id + " thread-id: " + threadId); throw new CompletionException(cause); } return null; }); return new CompletableFutureWrapper<>(f);}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23. 解锁成功唤排队线程在 org.redisson.pubsub.LockPubSub#onMessage中回去唤醒阻塞的线程，让执行前面的锁自旋逻辑，具体代码如下：
复制@Override
protected void onMessage(RedissonLockEntry value, Long message) { if (message.equals(UNLOCK_MESSAGE)) { Runnable runnableToExecute = value.getListeners().poll(); if (runnableToExecute != null) { runnableToExecute.run(); } value.getLatch().release(); } else if (message.equals(READ_UNLOCK_MESSAGE)) { while (true) { Runnable runnableToExecute = value.getListeners().poll(); if (runnableToExecute == null) { break; } runnableToExecute.run(); } value.getLatch().release(value.getLatch().getQueueLength()); }}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.- 办公室路由器如何设置为主题写（以办公室路由器接路由器的设置步骤和注意事项）
- Zuk圈铁耳机如何？实测告诉你！（一款颠覆传统的音乐体验，Zuk圈铁耳机深受好评。）
- 快速启动装XP系统教程（教你轻松快速安装XP系统，不再繁琐折腾！）
- 联想笔记本搭载CPUN3150（揭秘联想笔记本搭载CPUN3150的优劣势与性能表现）
- 如何更换蒙迪欧电脑板？（蒙迪欧电脑板更换教程及注意事项）
- 360Vizza（探索VR世界，畅享全新体验）
- 快速启动装XP系统教程（教你轻松快速安装XP系统，不再繁琐折腾！）
- 索尼爱立信老年机（简单易用、功能丰富的老年手机，）
- OPPOR9.11手机（OPPOR9.11手机）
- 从825开始更换硬盘的完整教程（一步步教你如何更换硬盘，让您的设备焕然一新）
- 电脑屏幕手动维修教程（简单易行的DIY维修，让你的电脑屏幕焕然一新）
- UbuntuKylin安装教程（详细步骤指导，让你快速掌握UbuntuKylin的安装方法）
- 影驰1080显卡综合评测（高性能与稳定性兼具，让你畅享游戏快感）
- i58400集成显卡（性能强劲，省电高效，适合轻度游戏和多媒体需求）
- 华为AR1200系列路由器（AR1200系列路由器产品特点及适用场景分析）
- 刀锋苹果装系统教程（解密刀锋苹果装系统步骤，让你的设备焕然一新）
- 探索24-240镜头的全能魅力（一镜走天下，尽显多样风采）
- 电脑安装打印机驱动的步骤（详细教程及注意事项）
- 一步学会如何制作引导优盘教程（轻松制作引导优盘，让文件传输更便捷）
- 方正ADS硬屏（探索方正ADS硬屏的前沿科技与卓越表现力）
随便看看
IT技术网益华科技香港云服务器源码下载源码库亿华云IT资讯网服务器租用企商汇益强科技编程之道益华科技科技前瞻益强科技益强前沿资讯亿华科技益华科技多维IT资讯极客编程技术快报亿华智造益强IT技术网汇智坊亿华灵动亿华云计算益强编程舍亿华云益强资讯优选云智核思维库智能时代极客码头云站无忧益强智未来码上建站益强智囊团IT资讯网益华IT技术论坛亿华互联益强编程堂
- Copyright © 2025 Powered by Redisson 高性能 Redis 分布式锁源码分析,码上建站 滇ICP备2023006006号-47sitemap