redis分布式锁-Redisson(RedissonClient)

最新推荐文章于 2025-04-17 15:55:50 发布
最新推荐文章于 2025-04-17 15:55:50 发布
阅读量1.7w 收藏 60
点赞数 10
分类专栏： java 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34484062/article/details/108517668
版权

RedissonClient中提供了好多种锁，还有其它很多实用的方法。Redisson是Redis官方推荐的Java版的Redis客户端。实现了对数据的增删改查等操作。Redisson实现了RedissonClient的接口。这里只介绍其中的锁。

依赖

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

重入锁 RedissonLock

重入锁可以通过Redisson的getLock方法获取

@Override
public RLock getLock(String name) {
    return new RedissonLock(connectionManager.getCommandExecutor(), name);
}
/**
     * 获取锁-同一个线程可重入
     * @param lockKey  锁的名称
     * @param waitTime 获取锁的等待时间
     * @param leaseTime 锁的持续时间
     * @param unit  时间的单位
     * @return 获取锁的结果
     */
    public Boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 1. 最常见的使用方法
            //lock.lock();
            // 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
            //lock.lock(10, TimeUnit.SECONDS);
            boolean locked = lock.tryLock(waitTime, leaseTime, unit);
            if (locked) lockKeys.add(lockKey);
            return locked;
        } catch (InterruptedException e) {
            System.out.println(String.format("尝试获取锁%s失败", lockKey));
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }

    /**
     * 解锁 - 重入的方式，所以同一个线程加了几次锁就要释放几次锁
     * @param lockKey 锁的值
     */
    public boolean unLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，和是否当前线程加的锁。
                lock.unlock();
                return lockKeys.remove(lockKey);
            }
        } catch (Exception e) {
            System.out.println(String.format("解锁锁%s失败", lockKey));
            e.printStackTrace();
        }
        return false;
    }

重入锁的异步执行方式

/**
     * 异步获取锁-同一个线程可重入
     * @param lockKey  锁的名称
     * @param waitTime 获取锁的等待时间
     * @param leaseTime 锁的持续时间
     * @param unit  时间的单位
     * @return 获取锁的结果
     */
    public Boolean tryLockAsync(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 1. 最常见的使用方法
            //lock.lockAsync();
            // 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
            //lock.lockAsync(10, TimeUnit.SECONDS);
            RFuture<Boolean> locked = lock.tryLockAsync(waitTime, leaseTime, unit);
            if (locked.get()) lockKeys.add(lockKey);
            return locked.get();
        } catch (InterruptedException | ExecutionException e) {
            System.out.println(String.format("尝试获取锁%s失败", lockKey));
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }

    /**
     * 解锁 - 重入的方式，所以同一个线程加了几次锁就要释放几次锁
     * @param lockKey 锁的值
     */
    public boolean unAsyncLock(String lockKey) {
        try {
            RLock lock = redissonClient.getLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，和是否当前线程加的锁。
                RFuture<Void> future = lock.unlockAsync();
                if(future.await(5 * 1000) && future.isSuccess()) {
                    return lockKeys.remove(lockKey);
                }
            }
        } catch (Exception e) {
            System.out.println(String.format("解锁%s失败", lockKey));
            e.printStackTrace();
        }
        return false;
    }

公平锁：

改公平锁是可重入的，在提供了自动过期解锁功能的同时，保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程。同时也提供了异步的方式。实现方式参照上一个锁的实现。

@Override
public RLock getFairLock(String name) {
    return new RedissonFairLock(connectionManager.getCommandExecutor(), name);
}

 

/**
     * 公平锁
     *
     * @param lockKey 锁的名称
     * @param waitTime 获取锁的等待时间
     * @param leaseTime 锁的持续时间
     * @param unit 时间的单位
     *
     * @return 获取锁的结果
     */
    public Boolean tryFairLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getFairLock(lockKey);
        try {
            // 1. 最常见的使用方法
            //lock.tryLock();
            // 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
            //lock.tryLock(10, TimeUnit.SECONDS);
            boolean locked = lock.tryLock(waitTime, leaseTime, unit);
            if (locked)
                lockKeys.add(lockKey);
            return locked;
            /* 异步实现方式
            lock.lockAsync();
            lock.lockAsync(10, TimeUnit.SECONDS);
            RFuture<Boolean> locked = lock.tryLockAsync(waitTime, leaseTime, unit);
            if (locked.get()) lockKeys.add(lockKey);
            return locked.get();*/
        } catch (InterruptedException e) {
            System.out.println(String.format("尝试获取锁%s失败", lockKey));
            e.printStackTrace();
        }
        return Boolean.FALSE;
    }

    /**
     * 解锁 - 重入的方式，所以同一个线程加了几次锁就要释放几次锁
     *
     * @param lockKey 锁的值
     */
    public boolean unFairLock(String lockKey) {
        try {
            RLock lock = redissonClient.getFairLock(lockKey);
            if (null != lock && lock.isHeldByCurrentThread()) { //判断锁是否存在，和是否当前线程加的锁。
                lock.unlock();
                return lockKeys.remove(lockKey);

                //异步方式删除锁
                /*RFuture<Void> future = lock.unlockAsync();
                if (future.await(5 * 1000) && future.isSuccess()) {
                    return lockKeys.remove(lockKey);
                }*/
            }
        } catch (Exception e) {
            System.out.println(String.format("解锁%s失败", lockKey));
            e.printStackTrace();
        }
        return false;
    }

联锁（MultiLock）

Redisson的RedissonMultiLock对象可以将多个RLock对象关联为一个联锁，每个RLock对象实例可以来自于不同的Redisson实例。需要注意的是，在锁的释放时，可以单独释放Redisson添加的锁，其他锁不会释放依旧存在。

/**
     * 连锁-只有所有的RedissonClient都锁成功才算成功
     *
     * @param waitTime 获取锁的等待时间
     * @param leaseTime 锁的持续时间
     * @param unit 时间的单位
     *
     * @return 获取锁的结果
     */
    public Boolean tryMultiLock(RedissonClient redisson1,RedissonClient redisson2, long waitTime, long leaseTime, TimeUnit unit){
        RLock lock1 = redisson1.getLock("zhong:test:lock1");
        RLock lock2 = redisson2.getLock("zhong:test:lock2");
        RLock lock = redissonClient.getMultiLock(lock1, lock2);
        try {
            // 同时加锁：lock1 lock2 lock3, 所有的锁都上锁成功才算成功。
            lock.lock();
            // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
            boolean res = lock.tryLock(waitTime, unit);
            return res;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return false;
    }
    /**
     * 连锁 - 需要遵循谁加的锁设计释放锁，可以单独释放自己加的锁
     *
     */
    public boolean unMultiLock(RedissonClient client ,RedissonClient client1) {
        try {
            List<RLock> locks = new ArrayList<>();
            locks.add(client.getLock("zhong:test:lock1"));
            locks.add(client1.getLock("zhong:test:lock2"));
            RedissonMultiLock lock = new RedissonMultiLock(locks.toArray(new RLock[0]));
            lock.unlock();

            //异步方式删除锁
            /*RFuture<Void> future = lock.unlockAsync();
            if (future.await(5 * 1000) && future.isSuccess()) {
                return lockKeys.remove(lockKey);
            }*/
        } catch (Exception e) {
            System.out.println(String.format("解锁失败"));
            e.printStackTrace();
            return false;
        }
        return true;
    }

 RedissonClient还提供了红锁，读写锁等。

        在实际应用中我们最常用的分布式锁一般都是设置定时过期的。这样的锁在实际应用中存在一个问题就是服务宕机或重启这个锁在redis上是一直存在的。一旦重启就可能会导致所有线程无法获取到锁。解决办法就是在加锁的时候将锁记录到Set里面。释放锁的时候将记录Set中的锁删除，在服务停止之前就就根据set记录里面的锁先将欧锁释放。这样就能保证重启后能获取到锁。实现方式参考DisposableBean的实现方式。

https://www.javadoc.io/doc/org.redisson/redisson/3.11.6/org/redisson/api/RLockAsync.html

https://www.cnblogs.com/cjsblog/p/9831423.html

https://blog.csdn.net/clypm/article/details/80598074

 

 

Redis分布式锁Redisson
梵高
08-23 736
原理：利用setnx的互斥性；释放锁时判断线程标示 缺陷：不可重入、无法重试、锁超时失效。原理：利用hash结构，记录线程标示和重入次数；利用watchDog延续锁时间；利用信号量控制锁重试等待。分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。在释放锁时先获取锁中的线程标示，判断是否与当前线程标示一致。在获取锁时存入线程标示（可以用UUID表示）缺陷：redis宕机引起锁失效问题。互斥：确保只能有一个线程获取锁。如果不一致则不释放锁。
Redis系列学习文章分享---第六篇（Redis实战篇--Redis分布式锁+实现思路+误删问题+原子性+lua脚本+Redisson功能介绍+可重入锁+WatchDog机制+multiLock）
热门推荐
私聊前往站内信：https://i.csdn.net/#/msg/chat/weixin_44976692
03-18 2万+
Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid）和分布式锁服务的框架，提供了丰富的分布式对象和服务支持。它封装了Redis的分布式对象和服务，简化了Java应用程序对Redis的操作。Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid）和分布式锁服务的框架，提供了丰富的分布式对象和服务支持。它封装了Redis的分布式对象和服务，简化了Java应用程序对Redis的操作。
【征服redis5】redis的Redisson客户端
纵横千里 捭阖四方 的专栏
01-16 2954
Redisson 最初由 GitHub 用户 “mrniko” 创建，并在 Apache 2.0 许可证下发布。它的目标是提供一组强大的工具和 API，帮助开发人员在分布式环境中处理数据，并解决并发和一致性的问题。Redisson 是一款在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。它提供了很多分布式的java对象并直接映射到Redis服务器的数据结构。
Spring Boot整合Redisson如何实现高性能实时排行榜？
最新发布
程序员总部的博客
04-17 726
通过Spring Boot和Redisson，我们能够轻松实现一个高性能的实时排行榜系统。从基础的功能到性能优化，Redisson都提供了简洁而强大的API。如果你正在面临类似的需求，不妨动手试试吧！遇到问题也别慌，多查文档、多交流，技术成长就是这么一步步来的。
RedissonClient
大JAVA解决方案
07-29 9664
package com.sdk.cloud.storge.service.redisservice.config; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.apache.commons.lang.StringUtils; import org.redisson....
分布式Redis锁 - RedissonClient
占星安啦的博客
10-18 1万+
Redis Java Client选型-Jedis Lettuce Redisson 可重入锁（Reentrant Lock） 先写个单元测试试一下 public class RedisLockTest { private RedissonClient redissonClient; //请求的key private static final String demo ...
分布式锁工具Redisson
2301_77463738的博客
06-06 1191
AbstractQueuedSynchronizer是用来构建锁或者其他同步组件的基础框架，通过内置FIFO队列来完成资源获取线程的排队工作，他自身没有实现同步接口，仅仅定义了若干同步状态获取和释放的方法来供自定义同步组件使用（上图），支持独占和共享获取，这是基于模版方法模式的一种设计，给公平/非公平提供了土壤。Lettuce是一种可扩展的线程安全的 Redis 客户端，通讯框架基于Netty，支持高级的 Redis 特性，比如哨兵，集群，管道，自动重新连接和Redis数据模型。
Java 分布式锁：Redisson、Zookeeper、Spring 提供的 Redis 分布式锁封装详解
空
01-07 1245
Java 分布式锁：Redisson、Zookeeper、Spring 提供的 Redis 分布式锁封装详解
记录redisson实现redis分布式事务锁
04-24
本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁，以及在Spring Boot环境中如何进行集成。 首先，Redis作为一个内存数据库，其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多...
在一个分布式系统中，Redis分布式锁实现Redisson 15问
m0_73583876的博客
10-13 663
在一个分布式系统中，Redis分布式锁实现Redisson 15问
【Redis】--RedissonClient的Lock锁详解
寻梦友的博客
02-02 1348
redisson的分布式锁在实际开发中经常遇到，这里将详细介绍各种Lock的源码，通过源码来了解每个Lock的使用，以及介绍相关示例。
redisson中的分布式锁
怀着一颗学徒的心
11-09 336
它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。的参数来指定加锁的时间。
分布式锁 RedisSon
北执南念的博客
07-30 650
分布式锁 Redis+RedisSon
Redisson分布式锁
qq_43657722的博客
12-20 798
Redisson分布式锁
java redis分布式锁redisson
03-14
### Java Redis 分布式锁使用 Redisson 实现的方法 #### 创建 Maven 或 Gradle 依赖项 为了在项目中集成 Redisson，需先引入相应的依赖库。对于Maven构建工具而言，在`pom.xml`文件里添加如下配置： ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.17.6</version> </dependency> ``` 而对于Gradle来说，则是在`build.gradle`文件中增加下面的内容: ```groovy implementation 'org.redisson:redisson:3.17.6' ``` #### 初始化 Redisson 客户端实例 创建一个名为 `RedissonClient` 的单例来管理连接池和其他资源。 ```java import org.redisson.Redisson; import org.redisson.api.RedissonClient; import org.redisson.config.Config; public class RedissonUtil { private static final String REDIS_HOST = "localhost"; private static final int REDIS_PORT = 6379; private static volatile RedissonClient redissonClient; public static synchronized RedissonClient getRedissonClient(){ if (null == redissonClient){ Config config = new Config(); config.useSingleServer().setAddress("redis://" + REDIS_HOST + ":" + REDIS_PORT); redissonClient = Redisson.create(config); } return redissonClient; } } ``` 这段代码定义了一个静态方法用于返回唯一的 `RedissonClient` 对象，并确保只初始化一次[^1]。 #### 获取分布式锁并执行业务逻辑 当需要对某些共享资源实施互斥访问控制时，可以通过调用 `RLock lock = redisson.getLock(lockName)` 来获得一把基于给定名称的分布式可重入锁。一旦获取到了这把锁就可以安全地进行后续操作了。 ```java import org.redisson.api.RLock; import java.util.concurrent.TimeUnit; // ...其他导入语句... public void processWithDistributedLock(String resourceName) throws InterruptedException { RLock resourceLock = RedissonUtil.getRedissonClient().getLock(resourceName); try{ boolean isLocked = resourceLock.tryLock(5, 10, TimeUnit.SECONDS); // 尝试等待最多五秒去得到锁，设置十秒钟自动解锁超时 if(isLocked){ System.out.println(Thread.currentThread().getName()+"获得了锁"); // 执行具体的业务逻辑... Thread.sleep(2000L); // 假设这里是要做的工作 System.out.println(Thread.currentThread().getName()+"完成了任务"); }else{ throw new RuntimeException("未能取得锁定！"); } }finally{ if(resourceLock.isHeldByCurrentThread()){ resourceLock.unlock(); // 解除当前持有的锁 System.out.println(Thread.currentThread().getName()+"已解除锁"); } } } ``` 上述例子演示了如何利用 Redisson 库提供的 API 接口完成基本功能——尝试占有指定名字的空间范围内的独占权限；如果成功则继续下一步骤直到结束之前都要记得释放掉所占用的权利以便让别的进程有机会参与竞争[^4]。 #### 关闭客户端连接 应用程序关闭前应当妥善清理所有打开过的网络链接以及分配出去的对象实例。 ```java Runtime.getRuntime().addShutdownHook(new Thread(() -> { if(null != RedissonUtil.redissonClient && !RedissonUtil.redissonClient.isShuttingDown()){ RedissonUtil.redissonClient.shutdown(); } })); ``` 这样可以在JVM退出的时候优雅地断开与Redis服务器之间的通信链路。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值