Redis - Redisson

已于 2022-11-27 13:27:03 修改
阅读量963 收藏 2
点赞数
分类专栏： redis 文章标签： redis java
于 2022-08-19 18:11:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33753147/article/details/126429159
版权

目录

可重入锁

 MultiLock： 连锁

 代码实现:

布隆过滤器

Redis实现的分布式锁还存在一下问题:

 Redisson可以全部解决以上问题

1. Redisson获取的锁是可重入的锁

RLock lock = redissonClient.getLock("lock:order"); 

2. waitTime为重试时间，leaseTime为持有的超时时间

lock.tryLock(long waitTime, long leaseTime, TimeUnit unit)

3.不设置leaseTime，可以解决超时释放带来的并发安全隐患

4.解决主从一致性问题，采用连锁，多个节点都为主节点。同时获取全部节点的锁。

 引入依赖

        <!-- redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.17.5</version>
        </dependency>

添加配置

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        //配置
        Config config = new Config();
        //添加Redis地址，这里添加单点地址，也可以使用config.useClusterServers()添加集群地址
        config.useSingleServer().setAddress("redis://192.168.99.100:56379").setPassword("123321");
        //创建Redis对象
        return Redisson.create(config);
    }
}

使用Redisson提供的分布式锁

@Service
public class DistributePayImpl implements SinglePay {

    @Autowired
    SimpleRedisLock simpleRedisLock;

    @Autowired
    RedissonClient redissonClient;

    public void buyOrder(Long userId) {
        buyOrder_RedissionLock(userId);
    }

    private void buyOrder_RedissionLock(Long userId){
        String lockKey = "lock:order:" + userId;
        //使用Redisson获取锁
        RLock lock = redissonClient.getLock(lockKey);
        //tryLock无参为默认值,只尝试一次，获取不到就不等了，持有锁的时间为30s，超过自动释放
        boolean isLock = lock.tryLock();
        if (!isLock) {
            //获取锁失败,返回错误或重试
            //"一人只能下一单"
            return;
        }
        try {
            SinglePay proxy = (SinglePay) AopContext.currentProxy();
            proxy.createOrder(userId);
        } finally {
            lock.unlock();
        }
    }

    @Transactional
    public String createOrder(Long userId) {
        //查询数据库order中userId是否存在记录，存在则不让购买
        int count = queryOrderCount(userId);
        if (count > 0) {
            //已买过购买失败
            return "fail";
        }

        boolean success = order_count(userId);
        if (!success) {
            return "库存不足";
        }

        saveOrder(userId);
        return "成功";
//        }
    }

    private void saveOrder(Long userId) {
        //模拟提交订单插入数据库
        //insert into order values(userId.....);
    }

    private boolean order_count(Long userId) {
        //修改库存
        //update order_count set count = count -1 where userId =? and count >0;
        return true;
    }

    private int queryOrderCount(Long userId) {
        //模拟查询数据库
        //select count(*) from order where userId = ?
        return 0;
    }
}

可重入锁

redissonClient.getLock(key)获得锁为可冲入锁，在redis中存储的类型为hash类型
@Slf4j
@SpringBootTest
class RedissonTests {

    @Autowired
    private RedissonClient redissonClient;

    private RLock lock;

    @BeforeEach
    void setUp() {
        lock = redissonClient.getLock("lock:order");
    }

    @Test
    void testString() {
        boolean isLock = lock.tryLock();
        if (!isLock) {
            log.error("获取锁失败.....1");
            return;
        }
        try {
            log.info("获取锁成功......1");
            method2();
            log.info("开始执行业务......1");
        } finally {
            log.info("准备释放锁......1");
            lock.unlock();
        }
    }

    private void method2() {
        boolean isLock = lock.tryLock();
        if (!isLock) {
            log.error("获取锁失败.....2");
            return;
        }
        try {
            log.info("获取锁成功.....2");
            log.info("开始执行业务......2");
        } finally {
            log.info("准备释放锁......2");
            lock.unlock();
        }
    }
}

 根据上图可以发现，同一个线程可以多次获取锁，value值会增加。key的UUID和线程一一对应

 

 MultiLock： 连锁

同时获取多个Redis节点的锁，只有全部获取到才算是获取锁成功,否则视为失败 

 代码实现:

//连接多个Redis节点
@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        //配置
        Config config = new Config();
        //添加Redis地址，这里添加单点地址，也可以使用config.useClusterServers()添加集群地址
        config.useSingleServer().setAddress("redis://192.168.99.100:56379").setPassword("123321");
        //创建Redis对象
        return Redisson.create(config);
    }

    @Bean
    public RedissonClient redissonClient2() {
        //配置
        Config config = new Config();
        //添加Redis地址，这里添加单点地址，也可以使用config.useClusterServers()添加集群地址
        config.useSingleServer().setAddress("redis://192.168.99.100:56378").setPassword("123321");
        //创建Redis对象
        return Redisson.create(config);
    }
    
    @Bean
    public RedissonClient redissonClient3() {
        //配置
        Config config = new Config();
        //添加Redis地址，这里添加单点地址，也可以使用config.useClusterServers()添加集群地址
        config.useSingleServer().setAddress("redis://192.168.99.100:56377").setPassword("123321");
        //创建Redis对象
        return Redisson.create(config);
    }
}

@Slf4j
@SpringBootTest
class RedissonTests {

    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private RedissonClient redissonClient2;
    @Autowired
    private RedissonClient redissonClient3;
    private RLock lock;

    @BeforeEach
    void setUp() {
        RLock  lock1 = redissonClient.getLock("lock:order");
        RLock  lock2 = redissonClient2.getLock("lock:order");
        RLock  lock3 = redissonClient3.getLock("lock:order");
        //从多把锁中获取的最终的lock
        lock = redissonClient.getMultiLock(lock1,lock2,lock3);
    }

    @Test
    void testString() {
        boolean isLock = lock.tryLock();
        if (!isLock) {
            log.error("获取锁失败.....1");
            return;
        }
        try {
            log.info("获取锁成功......1");
            method2();
            log.info("开始执行业务......1");
        } finally {
            log.info("准备释放锁......1");
            lock.unlock();
        }
    }

    private void method2() {
        boolean isLock = lock.tryLock();
        if (!isLock) {
            log.error("获取锁失败.....2");
            return;
        }
        try {
            log.info("获取锁成功.....2");
            log.info("开始执行业务......2");
        } finally {
            log.info("准备释放锁......2");
            lock.unlock();
        }
    }
}

RLock lock = redissonClient.getMultiLock(lock1,lock2,lock3);

根绝多把锁获取最总错做的RLock对象，当tryLock成功时，会在所有的Redis的节点中存在key =lock:order的记录

布隆过滤器

        Config config = new Config();
        //添加Redis地址，这里添加单点地址，也可以使用config.useClusterServers()添加集群地址
        config.useSingleServer().setAddress("redis://192.168.99.100:56379").setPassword("123321");
        //创建Redis对象
        Redisson redisson = Redisson.create(config);
        RBloomFilter<String> bloomFilter = redisson.getBloomFilter("product:bloom");
        //初始化布隆过滤器:预计元素1000000L，误判率为1%
        bloomFilter.tryInit(1000000L,0.01);
        bloomFilter.add("1");//添加数据
        //判断在布隆过滤器中是否存在
        System.out.println(bloomFilter.contains("1"));//输出true
        System.out.println(bloomFilter.contains("8888"));输出false

naki_bb
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shiro-redisson基于Redis的ShiroCache和Session实现
08-06
`shiro-redisson` 模块就是为了解决这个问题，将 Shiro 的缓存（Cache）和会话（Session）管理功能与 Redis 结合，实现了基于 Redis 的分布式解决方案。 1. **Redisson 库的介绍** Redisson 是一个全面的 Redis ...
Redis 提升篇之 Redisson
shi1499415423的博客
09-21 895
Redisson 中，针对没有设置加锁超时时间的情况下，会设置一个默认的 30 秒，但是针对默认的 30 秒时间，若再到期后还没执行完该线程，就会出现线程安全问题，所以，Redisson 对设置默认时间的情况下，会提供一个自动延长加锁时间的操作，俗称看门狗机制即 watchdog 机制。这种情况看似没什么问题，但是不幸的事发生了，那就是客户端对原先的主节点加锁，加成之后还没有来得及同步给从节点，主节点宕机了，从节点变成了主节点，此时从节点是没有加锁信息的，如果有其它的客户端来加锁，是能够加锁成功的。
Redis-Redisson
麦 -_- 的博客
06-26 1130
redisson简洁版了解redisson详细锁分类介绍（代码版。
redisson分布式锁中waittime的设置
qq_37831759的博客
05-06 469
之前分布式锁中使用redisson的lock.tryLock(0,0,TimeUnit.SECONDS)这里的time直接就取的传入的waitTime，当time减少到小于0时，返回加锁失败！这么做的逻辑是releaseTime设置为0，实际上会使用默认的30s并触发看门狗机制。所以waitTime是没有什么默认值的，这么写相当于加锁失败立刻返回。设置为0实际会等待多少时间？实验一下，先加一个不会过期的锁，然后另一个线程试图获取锁。如果设置为0，在尝试获取不到锁后立刻就会返回失败。
分布式锁 redisson
PJC的博客
11-04 595
1、整合SpringBoot 1、导入依赖 ・ <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.11.1</version> </dependency> ・ 2、配置redisson @Configuration public class RedissonC
分布式锁简单入门以及三种实现方式介绍
AlbenXie的博客
10-12 580
很多小伙伴在学习Java的时候，总是感觉Java多线程在实际的业务中很少使用，以至于不会花太多的时间去学习，技术债不断累积！等到了一定程度的时候对于与Java多线程相关的东西就很难理解，今天需要探讨的东西也是一样的和Java多线程相关的！做好准备，马上开车！ 学过Java多线程的应该都知道什么是锁，没学过的也不用担心，Java中的锁可以简单的理解为多线程情况下访问临界资源的一种线程同步机制。 在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁
聊聊分布式锁——Redis和Redisson的方式
m0_53462955的博客
09-17 3198
聊聊分布式锁——Redis和Redisson的方式 一、什么是分布式锁 分布式~~锁，要这么念，首先得是『分布式』，然后才是『锁』 分布式：这里的分布式指的是分布式系统，涉及到好多技术和理论，包括CAP 理论、分布式存储、分布式事务、分布式锁… 分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。 分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器，处理更多的数据。 锁：对对，就是你想的那个，Javer 学的第一个锁应
redisson-redisson（多版本）
06-13
redisson-redisson（多版本）：redisson-redisson-3.22.0~redisson-redisson-3.11.6 redisson-redisson-3.22.0.zip redisson-redisson-3.22.0.tar.gz redisson-redisson-3.21.3.zip redisson-redisson-3.21.3.tar....
延时队列-Redisson
最新发布
05-14
通过Redisson做的延时队列
spring-boot-distributed-redisson:redis实现分布式锁 Spring Boot core for Redisson RedissonLock
05-17
Redisson实现分布式锁 有关Redisson实现分布式锁前面写了三篇博客作为该项目落地的铺垫。 1、 2、 3、 该项目可以直接运用于实际开发中，作为分布式锁使用。 一、项目概述 1、技术架构 项目总体技术选型 SpringBoot...
Tomcat-redisson.zip
01-20
如何正确搭建一个基于redisson实现的分布式session共享事例； apache-tomcat-9.0.30.tar.gz redis-5.0.7.tar.gz redisson-3.12.0.jar redisson-tomcat-9-3.12.0.jar
Redisson夺命15连问
mxt51220的博客
12-16 1211
当有线程释放了锁之后，其它加锁失败的线程就会来继续加锁，加锁之前会先判断一下set集合的头部的线程跟当前要加锁的线程是不是同一个，如果是的话，那就加锁成功，如果不是的话，那么就加锁失败，这样就实现了加锁的顺序性。指定和不指定超时时间的主要区别是，加锁成功之后的逻辑不一样，不指定超时时间时，会开启watchdog后台线程，不断的续约加锁时间，而指定超时时间，就不会去开启watchdog定时任务，这样就不会续约，加锁key到了过期时间就会自动删除，也就达到了释放锁的目的。答案肯定是有的，接着往下看。
redis：六、数据过期删除策略（惰性删除、定期删除）和基于redisson实现的分布式锁（看门狗机制、主从一致性）和面试模板
zhiaidaidai的博客
12-18 1803
Redis的过期删除策略：惰性删除 + 定期删除两种策略进行配合使用。
Redis之Redisson原理详解
上善若泪
06-11 3664
Redisson顾名思义，Redis的儿子，本质上还是Redis加锁，不过是对Redis做了很多封装，它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。
Redisson框架实现Redis分布式锁的实现原理
lh87270202的博客
02-25 1635
一、前言 先看一段Redisson框架调用 RLock lock = redisson.getLock("myLock"); lock.lock(); //.......业务代码 lock.unlock(); Redisson支持redis单实例、redis哨兵、redis cluster、redis master-slave等各种部署架构 二、Redisson实现redis分布式锁的底层原理 ...
redisson看门狗机制，redisson看门狗性能问题，redisson源码解析
秃了也弱了
06-30 4236
Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。我们可以看到，leaseTime != -1时，只执行tryLockInnerAsync方法，其它情况会执行下面的代码，而leaseTime 就是我们调用 lock(10, TimeUnit.SECONDS);方法传入的时间参数。由此可知：redisson如果只是用lock.
01_redisson分布式锁源码分析
爱喝咖啡的程序员的博客
06-26 390
01_redisson分布式锁源码分析一. 可重入锁1.1 重要参数1.1.1 加锁的时间(leasetime)1.2 分析源码1.2.1 初次加锁的过程1.2.2 Watch Dog定时检查和延长锁的有效期1.3 疑问1.3.1 Watch Dog间隔多久进行一次检查？如果发现锁仍然被持有，每次续约多长的有效期？1.3.2 为什么成功获得锁的客户端，获取到的锁的有效时长是0呢？二. 待解决的疑问 一. 可重入锁 1.1 重要参数 1.1.1 加锁的时间(leasetime) 某些方法执行非常耗时，如果超过
Redisson源码解读—可重入、锁续命详解
2301_81922209的博客
01-10 1271
Redisson源码解读。
spring-boot-starter-redis + redisson-spring-boot-starter + springboot 3.1 配置
05-26
1. 在 `pom.xml` 中添加 `spring-boot-starter-redis` 和 `redisson-spring-boot-starter` 依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-redis <groupId>org.redisson...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值