使用 Redisson 实现分布式锁—解决方案详解

于 2025-06-07 18:41:12 发布
阅读量1k 收藏 29
点赞数 27
分类专栏： Redis系列 文章标签： 分布式 wpf redis redisson
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36755535/article/details/148499108
版权

在这里插入图片描述

Redisson 是 Redis 官方推荐的 Java 客户端，提供了一系列分布式服务实现，其中分布式锁是其核心功能之一。本文将深入解析 Redisson 分布式锁的实现原理、高级特性和最佳实践。

一、Redisson 分布式锁的优势

与传统实现的对比
特性手动实现Redisson 实现
锁续期需手动实现看门狗内置自动续期机制
可重入性不支持原生支持可重入锁
锁类型基础锁公平锁/联锁/读写锁/红锁
等待机制自旋或阻塞订阅发布机制
异常处理手动处理完善的异常处理链
集群支持需自行处理故障转移原生支持Redis集群模式

二、核心实现原理

1. 加锁原子性保证

Redisson 使用 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]);
2. 看门狗锁续期机制
private void scheduleExpirationRenewal(long threadId) {
    // 每10秒续期一次
    Timeout task = commandExecutor.getConnectionManager()
        .newTimeout(timeout -> {
            // 续期逻辑
            RFuture<Boolean> future = renewExpirationAsync(threadId);
            future.onComplete((res, e) -> {
                if (e != null) {
                    // 异常处理
                    return;
                }
                if (res) {
                    // 递归调用实现循环续期
                    scheduleExpirationRenewal(threadId);
                }
            });
        }, lockWatchdogTimeout / 3, TimeUnit.MILLISECONDS);
}

三、完整使用示例

1. 添加 Maven 依赖
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.27.0</version>
</dependency>
2. 配置 Redisson 客户端
Config config = new Config();
config.useSingleServer()
       .setAddress("redis://127.0.0.1:6379")
       .setPassword("your_password")
       .setDatabase(0)
       .setConnectionPoolSize(64)
       .setConnectionMinimumIdleSize(24);
       
RedissonClient redisson = Redisson.create(config);
3. 基础锁使用
RLock lock = redisson.getLock("orderLock");

void processOrder(String orderId) {
    try {
        // 尝试获取锁，等待100秒，锁自动释放时间30秒
        if (lock.tryLock(100, 30, TimeUnit.SECONDS)) {
            // 关键业务逻辑
            Order order = orderService.getOrder(orderId);
            order.process();
            orderService.update(order);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        log.error("锁获取被中断", e);
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
            log.info("订单{}处理完成，锁已释放", orderId);
        }
    }
}

四、高级锁特性详解

1. 可重入锁（Reentrant Lock）
public void nestedLockExample() {
    RLock lock = redisson.getLock("reentrantLock");
    
    lock.lock();
    try {
        // 外层业务逻辑
        innerMethod(lock);
    } finally {
        lock.unlock();
    }
}

private void innerMethod(RLock lock) {
    // 内层方法再次获取锁
    lock.lock();  // 计数+1
    try {
        // 内层业务逻辑
    } finally {
        lock.unlock();  // 计数-1
    }
}
2. 公平锁（Fair Lock）
RLock fairLock = redisson.getFairLock("fairLock");
fairLock.lock();
try {
    // 按照请求顺序获取锁资源
    executeCriticalSection();
} finally {
    fairLock.unlock();
}
3. 读写锁（ReadWrite Lock）
RReadWriteLock rwLock = redisson.getReadWriteLock("resourceLock");

// 读操作
void readData() {
    RLock readLock = rwLock.readLock();
    readLock.lock();
    try {
        // 多个线程可并发读取
        return fetchDataFromDB();
    } finally {
        readLock.unlock();
    }
}

// 写操作
void writeData(Object data) {
    RLock writeLock = rwLock.writeLock();
    writeLock.lock();
    try {
        // 独占写权限
        updateDataInDB(data);
    } finally {
        writeLock.unlock();
    }
}
4. 联锁（MultiLock）
RLock lock1 = redisson.getLock("lock1");
RLock lock2 = redisson.getLock("lock2");
RLock lock3 = redisson.getLock("lock3");

// 同时获取多个锁
RedissonMultiLock multiLock = new RedissonMultiLock(lock1, lock2, lock3);
multiLock.lock();
try {
    // 操作多个资源
    updateResource1();
    updateResource2();
} finally {
    multiLock.unlock();
}

五、红锁（RedLock）实现

解决Redis集群脑裂问题

Config config1 = createConfig("redis://node1:6379");
Config config2 = createConfig("redis://node2:6379");
Config config3 = createConfig("redis://node3:6379");

RedissonClient client1 = Redisson.create(config1);
RedissonClient client2 = Redisson.create(config2);
RedissonClient client3 = Redisson.create(config3);

RLock lock1 = client1.getLock("globalLock");
RLock lock2 = client2.getLock("globalLock");
RLock lock3 = client3.getLock("globalLock");

// 构建红锁
RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);

try {
    // 尝试获取锁，锁定时间60秒
    if (redLock.tryLock(100, 60, TimeUnit.SECONDS)) {
        // 关键业务逻辑
        processGlobalResource();
    }
} finally {
    redLock.unlock();
    // 关闭客户端连接
    Stream.of(client1, client2, client3).forEach(RedissonClient::shutdown);
}

六、生产环境最佳实践

1. 锁命名规范
// 业务域:资源类型:资源ID
String lockKey = "order:processing:" + orderId;
RLock lock = redisson.getLock(lockKey);
2. 合理配置参数
config.setLockWatchdogTimeout(30_000); // 看门狗超时时间
config.setNettyThreads(32);           // 网络线程数

// 锁配置
RedissonFairLock lock = (RedissonFairLock) redisson.getFairLock("lock");
lock.setLockWatchdogTimeout(60_000);  // 覆盖全局配置
3. 异常处理策略
try {
    if (lock.tryLock(10, 30, SECONDS)) {
        // 业务逻辑
    }
} catch (RedisResponseTimeoutException e) {
    // Redis响应超时处理
    metrics.recordTimeout();
    throw new ServiceUnavailableException("Redis超时");
} catch (RedisConnectionException e) {
    // 连接异常处理
    fallbackProcessor.process();
} catch (Exception e) {
    // 通用异常处理
    log.error("锁操作异常", e);
} finally {
    unlockSafely(lock);
}

void unlockSafely(RLock lock) {
    try {
        if (lock.isHeldByCurrentThread() && lock.isLocked()) {
            lock.unlock();
        }
    } catch (IllegalMonitorStateException ex) {
        // 锁状态异常处理
    }
}
4. 监控与告警
// 监控锁等待时间
long start = System.currentTimeMillis();
if (lock.tryLock(waitTime, leaseTime, unit)) {
    long elapsed = System.currentTimeMillis() - start;
    metrics.recordLockWaitTime(elapsed);
    // ...
}

// 监控锁持有时间
LockHoldTimer timer = metrics.startLockHoldTimer();
try {
    // 业务逻辑
} finally {
    timer.stop();
}

// JMX监控
Redisson redisson = (Redisson) redissonClient;
redisson.getRemoteService().registerService(LockMetrics.class, lockMetrics);

七、故障场景处理方案

1. 客户端宕机处理
客户端 Redis 看门狗线程 获取锁成功(lease=30s) 返回成功 每10秒启动续期检查 续期请求 续期成功 客户端宕机 30秒后自动过期释放锁 客户端 Redis 看门狗线程
2. 网络分区处理
// 使用红锁提高可用性
RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
redLock.lock(10, TimeUnit.SECONDS); // 设置较短租期

// 添加监听器处理连接丢失
lock.addListener(new LockListener() {
    @Override
    public void onLockLost() {
        // 触发补偿机制
        compensationService.compensate();
    }
});

八、性能优化策略

1. 锁粒度优化
// 粗粒度锁（不推荐）
RLock coarseLock = redisson.getLock("orderProcessing");

// 细粒度锁（推荐）
RLock fineGrainedLock = redisson.getLock("order:" + orderId);
2. 锁分离技术
// 读多写少场景
RReadWriteLock rwLock = redisson.getReadWriteLock("resource");
rwLock.readLock().lock();  // 读操作
rwLock.writeLock().lock(); // 写操作

// 热点数据场景
long shardId = orderId % 16;
RLock shardedLock = redisson.getLock("order_lock:" + shardId);
3. 异步锁操作
// 异步获取锁
RFuture<Boolean> lockFuture = lock.tryLockAsync(10, 30, TimeUnit.SECONDS);

lockFuture.onComplete((res, ex) -> {
    if (res) {
        // 获取锁成功
        processAsync();
    } else {
        // 获取锁失败
        fallback();
    }
});

// 异步释放锁
lock.unlockAsync();

九、常见问题解决方案

1. 锁等待超时

场景：系统负载高时锁获取超时
解决方案：

// 指数退避策略
long baseDelay = 50;
long maxDelay = 1000;
Random random = new Random();

while (!lock.tryLock()) {
    long delay = baseDelay + random.nextInt((int) baseDelay);
    Thread.sleep(delay);
    baseDelay = Math.min(baseDelay * 2, maxDelay);
}
2. 锁提前释放

场景：GC暂停导致看门狗续期失败
解决方案：

// 增加续期超时时间
config.setLockWatchdogTimeout(60_000);

// 添加JVM参数减少GC暂停
-XX:+UseG1GC -XX:MaxGCPauseMillis=100
3. 锁状态不一致

场景：Redis故障转移后锁状态丢失
解决方案：

// 使用红锁
RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);

// 启用持久化
config.setLockWatchdogTimeout(0); // 禁用看门狗
lock.lock(30, TimeUnit.SECONDS); // 依赖Redis持久化

十、Redisson 与企业架构集成

Spring Boot 自动配置
@Configuration
public class RedissonConfig {
    
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson(@Value("${redis.address}") String address) {
        Config config = new Config();
        config.useSingleServer()
              .setAddress(address)
              .setConnectionPoolSize(64);
        return Redisson.create(config);
    }
    
    @Bean
    public DistributedLockFactory lockFactory(RedissonClient redisson) {
        return new RedissonLockFactory(redisson);
    }
}

@Service
public class OrderService {
    
    @Autowired
    private DistributedLockFactory lockFactory;
    
    public void processOrder(String orderId) {
        Lock lock = lockFactory.getLock("order:" + orderId);
        if (lock.tryLock()) {
            try {
                // 业务逻辑
            } finally {
                lock.unlock();
            }
        }
    }
}
与 Spring Cloud 集成
# application.yml
spring:
  cloud:
    distributed-lock:
      enabled: true
      provider: redisson
      redisson:
        config-file: classpath:redisson.yaml

@SpringBootApplication
@EnableDistributedLock
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class InventoryService {
    
    @DistributedLock(lockKey = "'inventory:' + #skuId")
    public void reduceStock(String skuId, int quantity) {
        // 无需手动加锁
        inventoryDao.reduce(skuId, quantity);
    }
}

总结：Redisson 分布式锁最佳实践

  1. 锁选择策略：

    • 普通场景：RLock 基础锁
    • 读多写少：RReadWriteLock 读写锁
    • 高可用要求：RedissonRedLock 红锁
    • 顺序执行：RedissonFairLock 公平锁

  2. 关键配置参数：

    # 看门狗续期时间（默认30秒）
lockWatchdogTimeout=30000 
# 锁等待时间（根据业务设置）
waitTime=5000
# 锁租期时间（大于业务执行时间）
leaseTime=30000

  3. 性能优化建议：

    • 锁粒度最小化
    • 读写锁分离
    • 避免长时间持有锁
    • 热点数据分片

  4. 容灾方案：

    • 多数据中心部署
    • 降级策略（本地锁/熔断）
    • 事务补偿机制

最终建议：

  • 生产环境使用 Redisson 3.24+ 版本
  • 集群环境使用红锁（至少3个独立主节点）
  • 结合 Prometheus + Grafana 监控锁指标
  • 定期进行混沌工程测试

通过合理使用 Redisson 分布式锁，可以构建出高并发、高可靠的分布式系统。但需谨记：分布式锁是最后的选择而非首选方案，优先考虑无锁设计（如CAS）、事务隔离级别优化等方案能获得更好的系统性能。

Redisson实现分布式锁完整实例 多线程模拟并发（单机）
glizhewen的博客
07-15 3094
1 前言 随着分布式系统以及spring cloud等微服务架构的普及，对于分布式锁的掌握成为了每个程序员必须掌握的基操。常见的分布式锁的实现方法有基于数据库，基于分布式协调系统，基于缓存三种。本文通过Redisson 分布式重入锁用法，来简单实现分布式锁。 加锁逻辑： 根据给定key判断锁存不存在 如果锁不存在则新增锁，并设置重入计数为1，并设置过期时间。 如果锁存在，且唯一标识匹配，则表明锁重入请求，重入计数+1，并设置过期时间。 如果锁存在，但唯一标识不匹配，则表明被其他线程占用，返回剩余过期时间。
【并发编程】Redisson 的分布式锁
最新发布
大家好，我是敖云岚，一个沉迷代码的 “技术玩家”。擅长 Java、C++ 开发，对 MySQL、Redis、RabbitMQ 等技术也颇有研究。博客里既有硬核技术干货，也有诙谐幽默的编程日常分享。愿和你一起，笑着学技术，快乐敲代码！
05-11 1344
Redisson 是一个开源的用于操作 Redis 的 Java 框架。与 Jedis 和 Lettuce 等轻量级的 Redis 框架不同，它提供了更高级且功能丰富的 Redis 客户端。它提供了许多简化 Redis 操作的高级 API，并支持分布式对象、分布式锁、分布式集合等特性。Redisson 可以设置分布式锁的过期时间，从而避免锁一直被占用而导致的死锁问题。
Redisson实现分布式锁
zhuge_long的专栏
04-03 2318
分布式锁
Redisson 实现分布式锁
m0_50742275的博客
03-02 1882
Redisson 实现分布式锁
【实战，用Redisson来实现分布式锁，真香~】
西楼的博客
12-10 367
可能是最完善的Redis 分布式锁原理与实战总结，建议收藏。 Redis 分布式锁使用SET指令就可以实现了么？在分布式领域CAP理论一直存在。 分布式锁的门道可没那么简单，我们在网上看到的分布式锁方案可能是有问题的。 让我来一步步带你深入分布式锁是如何一步步完善，在高并发生产环境中如何正确使用分布式锁。 在进入正文之前，我们先带着问题去思考： 什么时候需要分布式锁？ 加、解锁的代码位置有讲究么？ 如何避免出现锁再也无法删除？ 超时时间设置多少合适呢...
Redis分布式锁—Redisson+RLock可重入锁实现篇
niceyoo的博客
10-28 1万+
前言 平时的工作中，由于生产环境中的项目是需要部署在多台服务器中的，所以经常会面临解决分布式场景下数据一致性的问题，那么就需要引入分布式锁来解决这一问题。 针对分布式锁的实现，目前比较常用的就如下几种方案： 基于数据库实现分布式锁 基于 Redis 实现分布式锁 【本文】 基于 Zookeeper 实现分布式锁 接下来这个系列文章会跟大家一块探讨这三种方案，本篇为 Redis 实现分布式锁篇。 Redis分布式环境搭建推荐：基于Docker的Redis集群搭建 Redis分布式锁一览 说到 Red
Redisson分布式锁详解：使用方式、场景与底层机制
weixin_44343004的博客
02-15 1294
Redisson的分布式锁（RLock）基于Redis的原子操作实现，支持可重入、自动续期（看门狗）、公平锁等特性。自动续期：通过看门狗（Watchdog）机制避免锁超时释放。可重入性：同一线程可重复获取锁。高可用：支持Redis单机、哨兵、集群等模式。在实际使用Redisson分布式锁时，可能会遇到一些典型问题。Redisson分布式锁虽简化了分布式协作，但仍需开发者理解其机制与潜在风险。锁释放规范性：确保unlock()在finally中执行。超时时间与看门狗。
使用Redisson实现分布式锁：配置与使用详解
在分布式系统中，由于多台服务器同时处理请求，为了确保数据的一致性和避免并发访问带来的问题，常常需要使用分布式锁来实现对共享资源的互斥访问。分布式锁在多个节点上可以协调对共享资源的访问，确保在同一时间...
面试题详解：如何用Redis实现分布式锁？
siyuanwai的博客
03-16 2372
说一道常见面试题： 使用Redis分布式锁的详细方案是什么？ 一个很简单的答案就是去使用 Redission 客户端。Redission 中的锁方案就是 Redis 分布式锁的比较完美的详细方案。 那么，Redission 中的锁方案为什么会比较完美呢？ 正好，我用 Redis 做分布式锁经验十分丰富，在实际工作中，也探索过许多种使用 Redis 做分布式锁的方案，经过了无数血泪教训。 所以，在谈及 Redission 锁为什么比较完美之前，先给大家看看我曾经使用 Redis 做分布式锁遇到过的问题。
Redisson分布式锁实现详解：注解方式优雅加锁
因此，Redisson的分布式锁成为了一个理想的解决方案，它实现了Java的Lock接口，提供了一种高效且安全的锁机制。 Redisson分布式锁的常规使用方法包括： 1. 获取锁：通过`RLock lock = redisson.getLock("Lxlxxx_...
Redisson分布式锁源码篇
个人博客，欢迎收藏。
01-19 1928
一步一步带你分析Redisson的源码，详解可重入和自动重试原理底层实现。
Redisson锁的分析
weixin_44023129的博客
05-13 4472
Redison
Redisson之分布式锁解决商品秒杀简单示例
wl_Honest的博客
04-07 2929
一般电商商品秒杀活动会面临大量用户同时下单的情况，不仅要面临高并发的问题，还要保证下单数量不超过商品数量和用户对同一商品不能重复下单（保证商品不被同一个用户抢购完，也就是防黄牛）。 面对这些问题，可以采用Redis分布锁来解决，通过Redis中setnx命令来保证同一时间只有一个线程能够正常下单，待订单创建成功后解锁，其余线程再来抢锁。 首先模拟一下未采用Redis加锁的代码实现，创建了3张表：用户表、商品表和订单表 maven依赖： <dependencies>...
基于Redission实现分布式锁
热门推荐
YHJ
05-09 1万+
实现Redis的分布式锁，除了自己基于redis client原生api来实现之外，还可以使用开源框架：Redission Redisson是一个企业级的开源Redis Client，也提供了分布式锁的支持。 回想一下上一篇文章《基于Redis实现分布式锁》说的，如果自己写代码来通过redis设置一个值，是通过下面这个命令设置的。 SET anyLock unique_value NX PX 30000 这里设置的超时时间是30s，假如我超过30s都还没有完成业务逻辑的情况下，key会过期，其他
吊炸天Redisson 实现分布式锁
苦也不苦
12-19 583
package io.renren.utils; import org.redisson.Redisson; import org.redisson.api.RedissonClient; import org.redisson.config.Config; import org.springframework.context.annotation.Bean; import org.sprin...
redisson 分布式锁
Emine
05-04 1万+
需求背景： 在分布式多机部署的情况下，我们要求某一个方法，只能同一个时间只能被一台机器的一个线程执行。 在单机中，有synchronized，读写锁等方式可以解决同步问题。 但是，这些只能作用在同一个机器上，只能保证某一个机器中的方法，不会同时执行。多台机器还是可以同时执行。 这时，就需要借助介质redisson，基于redis的分布式锁。。 前提不多说了，先安装好redis，使用...
Redisson实现Redis分布式锁的N种姿势
weixin_33968104的博客
12-03 2777
前几天发的一篇文章《Redlock：Redis分布式锁最牛逼的实现》，引起了一些同学的讨论，也有一些同学提出了一些疑问，这是好事儿。本文在讲解如何使用Redisson实现Redis普通分布式锁，以及Redlock算法分布式锁的几种方式的同时，也附带解答这些同学的一些疑问。 Redis几种架构 Redis发展到现在，几种常见的部署架构有： 单机模式； ...
基于redisson实现分布式锁入门例子
gudaichaoren的博客
06-17 651
引入： 一.为什么要使用分布式锁，用同步关键字synchronized，或者lock锁不能实现吗？ 答：同步关键字与lock锁是基于jvm系统级别的，只能适用于同一jvm；对于微服务架构的各个单独部署的服务来说，各个微服务之间不同jvm，所以这时候只能依靠分布式锁来实现同步。 二.分布式锁的必须满足的特性？ 1互斥性：锁的最基本特性；2可重入：获取锁后可以再次获取，常见于递归调用的场景；3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

颜淡慕潇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值