Redisson 框架详解 && Redisson RLock 分布式可重入锁详解

于 2025-07-03 00:18:45 发布
阅读量535 收藏 10
点赞数 22
CC 4.0 BY-SA版权
分类专栏： 分布式理论&实践 文章标签： 分布式锁 Redisson Rlock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/149074399

(一) Redisson 框架详解：基于 Redis 的分布式协调利器

Redisson 是一款基于 Redis 的 Java 分布式协调框架，由 Redisson 团队开发（现归属于 Redis 官方生态）。它通过封装 Redis 的底层操作，提供了分布式锁、原子变量、分布式集合、分布式队列等高级功能，解决了分布式系统中资源竞争、数据一致性等核心问题。以下从核心功能、核心组件、实战示例到最佳实践，全面解析 Redisson 的设计与应用。

一、Redisson 核心定位与优势

1. 解决的问题

直接使用 Redis 原生 API 开发分布式系统时，面临以下痛点：

  • 操作复杂：需手动处理序列化、连接管理、异常重试。
  • 功能缺失：如分布式锁需自行实现（SETNX+EXPIRE 原子性问题）。
  • 性能损耗：频繁的网络 IO 和序列化操作影响效率。

Redisson 通过以下方式解决：

  • 封装底层操作：提供 RedissonClient 统一客户端，简化连接管理。
  • 内置高级组件：直接支持分布式锁、队列、集合等常用原语。
  • 优化性能：通过连接池、管道（Pipeline）、异步操作提升吞吐量。

2. 核心优势

特性说明价值
功能丰富内置 30+ 分布式组件（锁、队列、原子变量等）快速实现复杂分布式逻辑
高性能基于 Netty 异步 IO，单节点 QPS 超 10万支撑高并发场景
易用性API 设计贴近 Java 原生集合（如 RMap 类似 HashMap）降低学习成本
高可靠性支持 Redis 集群、哨兵、云托管（如 Redis Cloud）适配多种 Redis 部署模式

二、Redisson 核心组件与功能

1. 核心客户端：RedissonClient

RedissonClient 是 Redisson 的入口类，负责管理与 Redis 的连接、资源分配和生命周期。其初始化需指定 Redis 连接参数（单节点、集群、哨兵等）。

初始化示例
// 单节点 Redis 配置
Config config = new Config();
config.useSingleServer()
    .setAddress("redis://127.0.0.1:6379")
    .setPassword("your_password") // 可选
    .setDatabase(0)               // 数据库编号（默认 0）
    .setConnectionPoolSize(64)    // 连接池大小
    .setTimeout(3000);            // 连接超时时间（3秒）

// 集群模式配置
// config.useClusterServers()
//     .addNodeAddress("redis://node1:6379", "redis://node2:6379");

// 创建客户端（阻塞直到连接成功）
RedissonClient redisson = Redisson.create(config);

2. 分布式锁：RLock

RLock 是 Redisson 提供的分布式可重入锁，基于 Redis 的 SETNX 和 EXPIRE 命令实现，支持自动续期（看门狗机制），解决传统分布式锁的续期难题。

核心特性
  • 可重入性：同一线程可多次获取同一锁（通过内部计数实现）。
  • 自动续期：后台线程每 10ms 检查锁状态，若剩余时间 < 1/3 锁时间，自动延长至原锁时间（默认 30s）。
  • 公平锁：支持公平锁模式（按等待队列顺序获取锁）。
代码示例
// 获取 RLock 实例（锁名称为 "order:lock"）
RLock lock = redisson.getLock("order:lock");

try {
    // 尝试获取锁（等待 10s，锁有效期 30s）
    boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (locked) {
        try {
            // 执行业务逻辑（如扣减库存）
            System.out.println("获取锁成功，执行扣库存...");
            Thread.sleep(5000); // 模拟耗时操作
        } finally {
            // 释放锁（仅当前线程持有时有效）
            lock.unlock();
        }
    } else {
        System.out.println("获取锁失败，等待重试...");
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}
高级用法
  • 公平锁：通过 lock.tryLock(0, leaseTime, TimeUnit.SECONDS, true) 开启公平模式。
  • 条件变量：结合 RLockCondition 实现等待/通知机制（类似 Object.wait()）。

3. 分布式队列：RQueue

RQueue 是 Redisson 提供的分布式队列，支持 FIFO（先进先出）和 LIFO（后进先出）模式，底层基于 Redis 的 LPUSH/RPOP 或 BRPOP/BLPOP 命令实现。

核心特性
  • 阻塞操作：支持 take() 阻塞获取元素（队列为空时等待）。
  • 批量操作：支持 addAll()、removeAll() 批量添加/删除元素。
  • 持久化：依赖 Redis 持久化配置（RDB/AOF）。
代码示例（FIFO 队列）
// 初始化 FIFO 队列（队列名称为 "task:queue"）
RQueue<String> queue = redisson.getQueue("task:queue");

// 生产者：添加任务
queue.add("order_123_task");
queue.add("user_456_task");

// 消费者：阻塞获取任务（超时 5s）
try {
    String task = queue.poll(5, TimeUnit.SECONDS);
    if (task != null) {
        System.out.println("处理任务：" + task);
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}
高级用法
  • 优先级队列：使用 RPriorityQueue 按优先级排序（需自定义比较器）。
  • 延迟队列：结合 RDelayedQueue 实现延迟任务（如定时邮件发送）。

4. 分布式集合：RMap、RSet、RList

Redisson 提供了丰富的分布式集合类，完全兼容 Java 标准集合接口（如 Map、Set、List），底层基于 Redis 的哈希（Hash）、集合（Set）、列表（List）数据结构实现。

核心组件
组件对应 Redis 数据结构特性
RMapHash支持 put、get、remove 等操作，自动序列化值
RSetSet支持 add、remove、contains，自动去重
RListList支持 add、get、remove，按索引操作
RSortedSetSorted Set支持按分数排序，addScore、removeScore
代码示例（RMap）
// 初始化 RMap（名称为 "user:info"）
RMap<String, Object> userMap = redisson.getMap("user:info");

// 写入数据（自动序列化）
userMap.put("123", new User("张三", 25)); // User 需实现 Serializable

// 读取数据（自动反序列化）
User user = (User) userMap.get("123");
System.out.println(user.getName()); // 输出 "张三"

// 原子操作：递增版本号
userMap.putIfAbsent("123", new User("张三", 25)); // 仅当键不存在时写入

5. 分布式原子变量：RAtomicLong、RAtomicDouble

RAtomicLong 和 RAtomicDouble 提供跨进程的原子计数功能，基于 Redis 的 INCR、DECR 等命令实现，适用于统计接口调用次数、限流等场景。

代码示例（RAtomicLong）
// 初始化原子计数器（名称为 "api:call:count"）
RAtomicLong apiCallCount = redisson.getAtomicLong("api:call:count");

// 原子递增（返回新值）
long newCount = apiCallCount.incrementAndGet();
System.out.println("当前调用次数：" + newCount);

// 原子递减（不低于 0）
long decremented = apiCallCount.addAndGet(-1);
if (decremented < 0) {
    apiCallCount.set(0); // 防止负数
}

6. 其他高级组件

  • 分布式信号量（RSemaphore）：控制并发线程数（如限制数据库连接池的最大连接数）。
  • 分布式倒计时门闩（RCountDownLatch）：协调多个线程等待某个事件完成（如批量任务完成通知）。
  • 分布式事务（RTransaction）：支持跨 Redis 键的原子操作（如转账场景中扣减 A 账户余额并增加 B 账户余额）。

三、Redisson 实战示例：秒杀系统库存扣减

以秒杀场景中的库存扣减为例，演示 Redisson 如何解决超卖问题。

需求背景

商品库存为 100，需保证高并发下（10万+请求）同一时间仅一个线程扣减库存，避免超卖。

实现步骤

  1. 初始化 Redisson 客户端：连接 Redis 集群。
  2. 定义分布式锁：使用 RLock 保证互斥访问。
  3. 扣减库存逻辑：获取锁后检查库存，若充足则扣减。
代码实现
public class SeckillService {

    private final RedissonClient redisson;
    private final RMap<String, Integer> stockMap; // 存储商品库存（商品ID → 库存）

    public SeckillService(RedissonClient redisson) {
        this.redisson = redisson;
        this.stockMap = redisson.getMap("seckill:stock");
        // 初始化库存（商品ID为 "item:123"，库存 100）
        stockMap.putIfAbsent("item:123", 100);
    }

    public boolean seckill(String userId) {
        RLock lock = redisson.getLock("seckill:lock:item:123");
        try {
            // 尝试获取锁（等待 1s，锁有效期 5s）
            if (!lock.tryLock(1, 5, TimeUnit.SECONDS)) {
                return false; // 获取锁失败
            }

            // 检查库存
            Integer currentStock = stockMap.get("item:123");
            if (currentStock == null || currentStock <= 0) {
                return false; // 库存不足
            }

            // 扣减库存（原子操作）
            int newStock = currentStock - 1;
            stockMap.put("item:123", newStock);

            // 记录用户购买（可选，使用 RSet 存储已购买用户）
            RSet<String> purchasedUsers = redisson.getSet("seckill:purchased:item:123");
            purchasedUsers.add(userId);

            return true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 释放锁（仅当前线程持有时有效）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

四、最佳实践与注意事项

1. 连接管理优化

  • 连接池配置：根据业务并发量调整 connectionPoolSize（建议为 CPU 核心数 × 2）。
  • 超时设置：timeout 需小于 Redis 服务端的 timeout，避免连接被服务端主动关闭。

2. 锁的最佳实践

  • 缩小锁范围：按业务单元细化锁名称（如 seckill:lock:item:123 而非全局 seckill:lock），减少竞争。
  • 缩短锁持有时间：避免在锁内执行耗时操作（如数据库查询、远程调用），防止其他线程长时间等待。
  • 禁用自动续期：若业务执行时间确定且较短（如 < 1s），可通过 lock.setLeaseRenewal(false) 禁用自动续期，降低开销。

3. 分布式集合的使用

  • 序列化优化：默认使用 JDK 序列化，性能较差；推荐自定义序列化（如 Kryo、Protobuf）提升效率。
  • 批量操作：使用 addAll()、removeAll() 减少网络 IO 次数。

4. 监控与故障排查

  • Redis 监控：通过 INFO 命令或工具（如 RedisInsight）监控内存使用、QPS、延迟。
  • 锁状态监控：通过 Redis 的 KEYS 命令查看锁键是否存在（生产环境不建议频繁使用 KEYS，可用 SCAN 替代）。
  • 异常处理：捕获 RedissonException 及其子类（如 LockAcquireException），实现重试或降级逻辑。

五、Redisson 与其他框架对比

框架核心功能适用场景优势
Redisson分布式锁、队列、集合、原子变量高并发分布式系统（秒杀、任务调度）功能全面、API 简洁、性能优异
Curator分布式锁、选举、队列ZooKeeper 生态系统（强一致性场景）依赖 ZooKeeper，适合强一致需求
Spring Session分布式会话管理Web 应用会话共享与 Spring 生态深度集成

总结

Redisson 是基于 Redis 的一站式分布式协调框架，通过封装 Redis 的底层操作，提供了丰富的分布式组件（锁、队列、集合等），解决了分布式系统中的资源竞争、数据一致性等核心问题。其核心优势在于高性能、易用性和功能全面性，是构建高并发分布式系统的首选工具。

在实际使用中，需结合业务场景选择合适的组件（如锁用于互斥，队列用于异步任务），并注意连接管理和锁续期策略，确保系统的稳定性和性能。

(二) Redisson RLock 分布式可重入锁详解

RLock（Redisson Lock）是 Redisson 框架提供的分布式可重入锁，是解决分布式系统中资源竞争的核心组件。它基于 Redis 的 SETNX（原子性设置键值）和 EXPIRE（设置过期时间）命令实现，结合看门狗（Watchdog）机制解决锁续期问题，支持可重入、公平锁等特性，广泛应用于高并发场景下的互斥访问控制。

一、RLock 核心原理

1. 底层实现：Redis 原子操作

RLock 的核心依赖 Redis 的两个关键命令：

  • SETNX key value：原子性设置键 key 的值为 value（仅当 key 不存在时成功）。
  • EXPIRE key seconds：设置键 key 的过期时间（避免锁永久残留）。

通过 Lua 脚本将这两个操作合并为原子性操作，确保“加锁+设置过期时间”的原子性：

if redis.call('SETNX', KEYS[1], ARGV[1]) == 1 then
    redis.call('EXPIRE', KEYS[1], ARGV[2])
    return 1
else
    return 0
end

2. 看门狗（Watchdog）机制

RLock 内置后台线程（默认每 10ms 运行一次），用于自动续期锁的有效期：

  • 当锁被获取后，看门狗会检查锁的剩余时间。
  • 若剩余时间小于锁总有效期的 1/3（默认 30s 锁的 1/3 为 10s），则自动延长锁的有效期至原时长（30s）。
  • 若锁被释放或过期，看门狗停止续期。

这一机制避免了因业务执行超时导致锁提前失效的问题。

二、RLock 核心特性

特性说明价值
可重入性同一线程可多次获取同一锁（计数递增）支持递归调用、长事务
自动续期看门狗自动延长锁有效期（默认 30s）避免业务超时导致锁失效
公平锁支持公平锁模式（按等待队列顺序获取锁）防止线程饥饿，保证锁获取顺序
高可靠性依赖 Redis 高可用集群（主从/哨兵/云托管）避免单点故障导致锁服务不可用
高性能基于 Netty 异步 IO，单节点 QPS 超 10万支撑高并发场景

三、RLock 基础用法：获取与释放锁

1. 初始化 Redisson 客户端

使用前需先创建 RedissonClient 实例，连接 Redis 服务：

Config config = new Config();
config.useSingleServer()
    .setAddress("redis://127.0.0.1:6379") // Redis 地址
    .setPassword("your_password")         // 可选密码
    .setDatabase(0)                       // 数据库编号（默认 0）
    .setConnectionPoolSize(64);           // 连接池大小（根据并发调整）

RedissonClient redisson = Redisson.create(config);

2. 获取 RLock 实例

通过 RedissonClient 获取指定名称的锁：

RLock lock = redisson.getLock("order:lock"); // 锁名称（如 "order:lock"）

3. 获取锁（tryLock）

tryLock 方法支持设置等待时间和锁有效期，返回是否成功获取锁：

try {
    // 尝试获取锁：等待 10s，锁有效期 30s
    boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (locked) {
        try {
            // 执行业务逻辑（如扣减库存）
            System.out.println("获取锁成功，执行业务...");
            Thread.sleep(5000); // 模拟耗时操作
        } finally {
            // 释放锁（仅当前线程持有时有效）
            lock.unlock();
        }
    } else {
        System.out.println("获取锁失败，等待重试...");
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 恢复中断状态
}

4. 释放锁（unlock）

  • 自动释放：通过 try-finally 确保锁释放，避免因异常导致锁未释放。
  • 仅当前线程释放：unlock() 仅当当前线程持有锁时有效，否则抛出异常。

四、RLock 高级用法

1. 可重入锁

RLock 支持同一线程多次获取同一锁（计数递增），释放时计数递减，计数归零后锁完全释放：

public void recursiveOperation() throws InterruptedException {
    RLock lock = redisson.getLock("recursive:lock");
    if (lock.tryLock(0, 30, TimeUnit.SECONDS)) { // 0 表示不等待，直接获取
        try {
            System.out.println("第一次获取锁，计数：" + lock.getHoldCount()); // 输出 1
            
            // 递归调用（再次获取锁）
            if (lock.tryLock(0, 30, TimeUnit.SECONDS)) {
                try {
                    System.out.println("第二次获取锁，计数：" + lock.getHoldCount()); // 输出 2
                } finally {
                    lock.unlock(); // 计数减为 1
                }
            }
        } finally {
            lock.unlock(); // 计数减为 0，锁完全释放
        }
    }
}

2. 公平锁模式

默认情况下，RLock 是非公平锁（按抢占顺序获取锁）。通过 tryLock 的第四个参数开启公平锁模式（按等待队列顺序获取锁）：

// 第四个参数为 true 表示公平锁
boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS, true);

3. 条件变量（RLockCondition）

RLock 支持结合 Condition 实现等待/通知机制（类似 Object.wait()/notify()）：

RLock lock = redisson.getLock("condition:lock");
Condition condition = lock.newCondition();

// 线程 A：等待条件满足
new Thread(() -> {
    try {
        lock.lock();
        try {
            System.out.println("线程 A 等待条件...");
            condition.await(10, TimeUnit.SECONDS); // 等待 10s 或被唤醒
            System.out.println("线程 A 条件满足，继续执行");
        } finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// 线程 B：唤醒线程 A
new Thread(() -> {
    try {
        Thread.sleep(5000); // 等待 5s 后唤醒
        lock.lock();
        try {
            condition.signal(); // 唤醒线程 A
        } finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

五、RLock 最佳实践

1. 合理设置锁有效期

  • 业务耗时评估：根据业务逻辑的最大执行时间设置锁有效期（如业务最多执行 5s，则锁有效期设为 10s）。
  • 避免过长有效期：过长的有效期会增加锁被其他线程抢占的风险；过短可能导致业务未完成锁已失效。

2. 缩小锁范围

  • 细粒度锁：按业务单元细化锁名称（如 order:123:lock 而非全局 order:lock），减少锁竞争。
  • 避免全局锁：全局锁会严重影响性能，仅在必要时使用（如系统级配置修改）。

3. 缩短锁持有时间

  • 异步处理：将非核心逻辑（如日志记录、消息通知）移至锁外异步执行。
  • 批量操作：合并多次锁内操作为一次（如批量查询代替多次查询）。

4. 监控与故障排查

  • 锁状态监控：通过 Redis 的 KEYS 命令（生产环境建议用 SCAN）查看锁键是否存在，或使用 Redis Insight 可视化工具。
  • 异常处理：捕获 LockAcquireException（获取锁失败）、IllegalMonitorStateException（非法释放锁）等异常，实现重试或降级逻辑。

5. 禁用自动续期（可选）

若业务执行时间确定且远小于锁有效期（如 < 1s），可禁用自动续期以降低开销：

lock.setLeaseRenewal(false); // 禁用自动续期

六、RLock 与其他分布式锁对比

特性Redisson RLockZooKeeper InterProcessMutex数据库锁
互斥性强（Redis 原子操作）强（ZooKeeper 临时节点）弱（依赖行锁）
可重入性支持支持不支持
自动续期看门狗自动续期会话超时自动释放需手动实现
性能高（单节点 10万+ QPS）中（单节点 5000+ QPS）低（行锁影响 QPS）
适用场景高并发互斥（秒杀、库存扣减）强一致性场景（金融交易）传统系统改造

总结

RLock 是 Redisson 提供的高性能、高可靠分布式可重入锁，通过封装 Redis 的原子操作和看门狗机制，解决了分布式系统中的资源竞争问题。其核心优势在于简单易用、自动续期、支持可重入，是构建高并发分布式系统的首选锁方案。

实际使用中，需结合业务场景合理设置锁有效期、缩小锁范围，并通过监控确保锁的稳定性。对于强一致性要求的场景（如金融交易），可考虑结合 ZooKeeper 等强一致协调服务；对于高并发场景（如秒杀），RLock 是最优选择。

Redisson分布式锁详解：使用方式、场景与底层机制
weixin_44343004的博客
02-15 1317
Redisson的分布式锁（RLock）基于Redis的原子操作实现，支持可重入、自动续期（看门狗）、公平锁等特性。自动续期：通过看门狗（Watchdog）机制避免锁超时释放。可重入性：同一线程可重复获取锁。高可用：支持Redis单机、哨兵、集群等模式。在实际使用Redisson分布式锁时，可能会遇到一些典型问题。Redisson分布式锁虽简化了分布式协作，但仍需开发者理解其机制与潜在风险。锁释放规范性：确保unlock()在finally中执行。超时时间与看门狗。
Java 分布式锁：Redisson、Zookeeper、Spring 提供的 Redis 分布式锁封装详解
空
01-07 1275
Java 分布式锁：Redisson、Zookeeper、Spring 提供的 Redis 分布式锁封装详解
使用 Redisson 实现分布式锁—解决方案详解
颜淡慕潇
06-07 1115
本文将深入解析 Redisson 分布式锁的实现原理、高级特性和最佳实践。
Redisson源码详解（redis分布式锁）
xweiran的博客
05-05 466
读写锁利用的是reids的hash和string，hash（外面的大key是锁名称）里面的第一个键是mode，值是读写模式read或write，以后的键是锁标识UUID+threadId，值是重入的次数。执行加锁和释放锁的lua脚本的逻辑不一样。写锁是不会就超时记录的，因为写锁在同一时间只有一个线程能够获取(写写互斥)，锁的超时时间就是线程持有锁的超时时间，所以不需要。公平锁靠的是hash存放持有锁的线程信息，list集合存放等待的线程，zset集合则是存放线程以及等待锁的时间。
【分布式锁篇】Redisson详解
You’re a wanderer just like me
08-02 3456
一个基于Redis实现的分布式工具，有基本分布式对象和高级又抽象的分布式服务，为每个试图再造分布式轮子的程序员带来了大部分分布式问题的解决办法。
Redisson分布式锁使用详解
2301_76166241的博客
07-24 1528
通常我们都会将redisson实例注入到方法类里面，然后调用加锁方法进行加锁，如果其他业务方法也需要加锁执行，将会产生很多重复代码，由此采用AOP切面的方式，只需要通过注解的方式就能将方法进行加锁处理。自定义注解@InheritedString errorDesc() default "系统正常处理，请稍后提交";切面类实现@Aspect@Component@Autowiredtry {if (!lock) {
redisson锁的可重入、可重试、超时续约原理详解
m0_73856804的博客
06-11 1542
redisson分布式锁原理：可重入：利用hash结构记录线程id和重入次数，当线程获取锁失败后去判断锁包含的线程id是否一致，如果一致，则让其获取锁，并且重入次数加一。在释放锁时，先去判断锁中的线程ID，再去判断重入次数是否为0，如果为0，则释放，不为0，则无视可重试：利用信号量和pubsub功能实现等待、唤醒、获取锁失败的重试机制。在第一次获取锁失败以后，并不是直接返回false，尝试获取锁的返回结果就是ttl（剩余有效时间），如果返回值为null。则获取锁成功，若不为null，则获取锁失败，
Redisson分布式锁实现及原理详解
weixin_43287459的博客
09-11 2250
客户端从N个 Redis 实例中请求锁，并设置相同的键、值和过期时间。客户端计算从每个 Redis 实例成功获取锁的时间。如果客户端能在大多数（即N/2 + 1个）Redis 实例中获取到锁，并且获取锁的总时间小于设定的超时时间，那么客户端成功获得了锁。如果客户端在大多数实例中获取了锁，客户端可以进行对共享资源的操作。如果锁超时后仍未成功获得足够多的实例锁，或者在操作过程中锁过期，则客户端应放弃该锁，等待下一次重试。操作完成后，客户端会向所有 Redis 实例发出解锁命令，以释放锁。
Redisson 分布式锁详解
Java是世界上最好的语言
11-24 1645
简单使用 下面通过 Redisson 框架封装的分布式锁机制，来演示一下分布式锁的实现。 引入依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.16.0</version> </dependency> 测试 public class RedisL
【实践篇】4.3 Redis之Redisson 7种分布式锁使用指南
日拱一卒无有尽，功不唐捐终入海
09-10 2284
前两章我们了解了《【实践篇】Redis最强Java客户端(一)之Redisson入门介绍》和《【实践篇】Redis最强Java客户端(二)之Redisson基础概念》本章第三章主要介绍Redisson的七种分布式锁，分别是简单锁、公平锁、可重入锁、红锁、读写锁、信号量和闭锁。下面是每种锁的基本概念、使用方法以及性能和并发控制方面的考虑。
Java redisson实现分布式锁原理详解
08-24
Java Redisson 实现分布式锁原理详解 分布式锁的重要性 在分布式系统中，锁机制是非常重要的，它可以防止多个节点同时访问共享资源，避免数据不一致和错误。 Java Redisson 是一个流行的分布式锁实现，它提供了一...
分布式锁:Redisson源码解析——RLock（二）
weixin_47246944的博客
11-30 1402
一、复习 场景模拟 初始化 在获取锁的时候，会初始化一些参数，例如commandExecutor leaseTime uuid ● commandExecutor 命令执行器 ● leaseTime 持有锁的最大时间，租期 ● uuid 客户端的唯一标识 第一次加锁 设置获取到锁的主体，使用线程id作为标识 当未设置leaseTime的时候，也就是代表的锁可以无限持有时间 判断redis中是否已经存在了这个锁 第一次加锁肯定不存在，递增一个lockName为key的hash数据结构里面的一个key为uui
Redisson框架的分布式锁原理详解
它不仅提供了一系列的分布式的Java对象，还提供了许多分布式服务，其中就包括分布式锁。 ### 1.1 Redisson框架概述 Redisson是一个基于Netty框架、实现了完全异步编程的纯Java驻内存数据网格（In-Memory Data Grid...
Android Framework学习笔记（五）应用程序启动过程(1).docx
07-02
Android Framework学习笔记（五）应用程序启动过程(1).docx
网络安全事件处置.pptx
07-02
网络安全事件处置.pptx
投资项目管理师投资建设项目实施考试模拟试题(二)-中大网校.doc
07-02
投资项目管理师投资建设项目实施考试模拟试题(二)-中大网校.doc
计算机专业项目代码：delphi家庭财务管理系统.7z
07-02
计算机专业毕业设计：C语言程序
高品质安全软件开发制程研究.docx
最新发布
07-02
高品质安全软件开发制程研究.docx
计算机专业项目代码：java银行帐目管理系统(源代码+论文).7z
07-02
计算机专业毕业设计项目源码、论文
redisson分布式锁详解
01-18
### Redisson 分布式锁实现原理 Redisson 提供了一种基于 Redis 的分布式锁实现方案，这种锁能够保证在多个节点之间同步操作的安全性和一致性。具体来说，当客户端尝试获取锁时，会向 Redis 发送命令创建一个带有唯一标识符的键值对[^1]。 如果该键成功设置，则表示当前线程获得了这把锁；反之则说明其他进程已经持有此资源而无法再次获得它。为了防止死锁情况发生，在设定超时期限之后仍未释放的话将会自动解锁并允许下一个等待者继续竞争下去。 此外，Redisson 还支持可重入锁机制——即同一个客户端可以多次申请相同的锁而不必担心造成阻塞现象。每次加锁都会增加计数器数值，并且只有当所有对应的解锁调用被执行完毕后才会真正移除这个锁定状态下的记录项。 ```java RLock lock = redissonClient.getLock("anyLock"); lock.lock(); try { // 执行业务逻辑... } finally { lock.unlock(); } ``` 这段代码展示了如何通过 `redissonClient` 获取名为 `"anyLock"` 的分布式互斥锁实例对象 `lock` ，并通过调用它的两个主要方法来控制临界区内的执行流程：进入前先上锁(`lock()`)，离开后再开锁 (`unlock()`)。 值得注意的是，上述例子中的简单形式并不适用于所有的应用场景。对于更复杂的需求而言，还可以利用带参数版本的方法来自定义一些行为特征，比如指定最大等待时间和保持有效期限等属性： ```java // 尝试获取锁, 最多等待10秒, 锁自动维持时间为2分钟 boolean res = lock.tryLock(10, 120, TimeUnit.SECONDS); if (res) { try { // 成功拿到锁后的处理过程... } finally { lock.unlock(); } } ``` 以上就是关于 Redisson 中实现分布式锁工作原理以及基本使用的介绍。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值