Redisson

于 2024-08-15 20:14:06 发布
阅读量943 收藏 16
点赞数 26
文章标签： wpf spring boot spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51607909/article/details/141230830
版权

一、分布式锁与本地锁

在高并发环境下，本地锁只能锁住当前的进程，无法锁住其他进程。

在分布式环境下，本地锁只能锁住当前服务，无法锁住其他服务器上部署的服务，集群环境需要共享一把锁，因此需要使用分布式锁。

例如：

二、分布式锁原理

分布式锁演进-基本原理

分布式锁演进-阶段一

 /**
     * 测试分布式锁
     */
    @Override
    public String testLock() throws Exception {
        // 1. 占分布式锁：去redis占坑
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock) {
            // 加锁成功，执行业务
            // 假设业务执行耗时5s
            Thread.sleep(5000);
            log.info("业务执行完成！");
            // 删除锁
            redisTemplate.delete("lock");
            return "success";
        } else {
            // 加锁失败。。。休眠10秒重试
            Thread.sleep(1000);
            return testLock();
        }
    }

分布式锁演进-阶段二

  /**
     * 测试分布式锁
     */
    @Override
    public String testLock() throws Exception {
        // 1. 占分布式锁：去redis占坑
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", UUID.randomUUID().toString());
        if (lock) {
            // 设置过期时间
            redisTemplate.expire("lock", 30, TimeUnit.SECONDS);
            // 加锁成功，执行业务 假设业务执行耗时5s
            Thread.sleep(5000);
            log.info("业务执行完成！");
            // 删除锁
            redisTemplate.delete("lock");
            return "success";
        } else {
            // 加锁失败。。。休眠10秒重试
            Thread.sleep(1000);
            return testLock();
        }
    }

分布式锁演进-阶段三

在阶段2的基础上，占锁的时候，就为锁设置过期时间，保证占有锁和设置过期时间为原子性操作。

    /**
     * 测试分布式锁
     */
    @Override
    public String testLock() throws Exception {
        // 1. 占分布式锁：去redis占坑
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", UUID.randomUUID().toString(), 30, TimeUnit.SECONDS);
        if (lock) {
            // 设置过期时间
            // redisTemplate.expire("lock", 30, TimeUnit.SECONDS);
            // 加锁成功，执行业务 假设业务执行耗时5s
            Thread.sleep(5000);
            log.info("业务执行完成！");
            // 删除锁
            redisTemplate.delete("lock");
            return "success";
        } else {
            // 加锁失败。。。休眠10秒重试
            Thread.sleep(1000);
            return testLock();
        }
    }

分布式锁演进-阶段四

 /**
     * 测试分布式锁
     */
    @Override
    public String testLock() throws Exception {
        // 1. 占分布式锁：去redis占坑
        String uuid = UUID.randomUUID().toString();
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 30, TimeUnit.SECONDS);
        if (lock) {
            // 设置过期时间
            // redisTemplate.expire("lock", 30, TimeUnit.SECONDS);
            // 加锁成功，执行业务 假设业务执行耗时5s
            Thread.sleep(5000);
            log.info("业务执行完成！");
            if (uuid.equals(getLock())) {
                // 删除锁
                redisTemplate.delete("lock");
            }
            return "success";
        } else {
            // 加锁失败。。。休眠10秒重试
            Thread.sleep(1000);
            return testLock();
        }
    }

    public String getLock() {
        return redisTemplate.opsForValue().get("lock");
    }

分布式锁演进-阶段五-最终形态


    /**
     * 测试分布式锁
     */
    @Override
    public String testLock() throws Exception {
        // 1. 占分布式锁：去redis占坑
        String uuid = UUID.randomUUID().toString();
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 30, TimeUnit.SECONDS);
        if (lock) {
            // 设置过期时间
            // redisTemplate.expire("lock", 30, TimeUnit.SECONDS);
            // 加锁成功，执行业务 假设业务执行耗时5s
            Thread.sleep(5000);
            log.info("业务执行完成！");

            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);

            // if (uuid.equals(getLock())) {
                // 删除锁
            // redisTemplate.delete("lock");
            // }
            return "success";
        } else {
            // 加锁失败。。。休眠10秒重试
            Thread.sleep(1000);
            return testLock();
        }
    }

    public String getLock() {
        return redisTemplate.opsForValue().get("lock");
    }

    /**
     * 从数据库查询并封装数据::分布式锁
     * @return
     */
    public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock() {

        //1、占分布式锁。去redis占坑      设置过期时间必须和加锁是同步的，保证原子性（避免死锁）
        String uuid = UUID.randomUUID().toString();
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
        if (lock) {
            System.out.println("获取分布式锁成功...");
            Map<String, List<Catelog2Vo>> dataFromDb = null;
            try {
                //加锁成功...执行业务
                dataFromDb = getDataFromDb();
            } finally {
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

                //删除锁
                stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList("lock"), uuid);

            }
            //先去redis查询下保证当前的锁是自己的
            //获取值对比，对比成功删除=原子性 lua脚本解锁
            // String lockValue = stringRedisTemplate.opsForValue().get("lock");
            // if (uuid.equals(lockValue)) {
            //     //删除我自己的锁
            //     stringRedisTemplate.delete("lock");
            // }

            return dataFromDb;
        } else {
            System.out.println("获取分布式锁失败...等待重试...");
            //加锁失败...重试机制
            //休眠一百毫秒
            try { TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }
            return getCatalogJsonFromDbWithRedisLock();     //自旋的方式
        }
    }

三、分布式锁实现

官方介绍：

在来看一下分布式锁的最终形态，主要的问题在于：

  1. 保证加锁和删除锁是一个原子性的操作。
  2. 业务执行时间较长，锁的自动续期问题。

public Map<String, List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock() {
    //1、占分布式锁。去 redis 占坑
    String uuid = UUID.randomUUID().toString();
    Boolean lock =
    redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,TimeUnit.SECONDS);
    if(lock){
        System.out.println("获取分布式锁成功...");
        //加锁成功... 执行业务
        //2、设置过期时间，必须和加锁是同步的，原子的
        //redisTemplate.expire("lock",30,TimeUnit.SECONDS);
        Map<String, List<Catelog2Vo>> dataFromDb;
        try{
            dataFromDb = getDataFromDb();
        }finally {
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('del', KEYS[1]) else return 0 end";
            //删除锁
            Long lock1 = redisTemplate.execute(new
                                               DefaultRedisScript<Long>(script, Long.class)
                                               , Arrays.asList("lock"), uuid);
        }
        //获取值对比+对比成功删除=原子操作 lua 脚本解锁
        // String lockValue = redisTemplate.opsForValue().get("lock");
        // if(uuid.equals(lockValue)){
        // //删除我自己的锁
        // redisTemplate.delete("lock");//删除锁
        // }
        return dataFromDb;
    }else {
        //加锁失败...重试。synchronized ()
        //休眠 100ms 重试
        System.out.println("获取分布式锁失败...等待重试");
        try{
            Thread.sleep(200);
        }catch (Exception e){
        }
        return getCatalogJsonFromDbWithRedisLock();//自旋的方式
    }
}

上述操作是相同的代码逻辑，可以将其抽取为一个工具类的形式。

四、Redission完成分布式锁

(一) 简介

Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分的利用了 Redis 键值数据库提供的一系列优势，基于 Java 实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。

官方文档：https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95

(二) 依赖

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

(三) 配置

// 默认连接地址 127.0.0.1:6379
RedissonClient redisson = Redisson.create();
Config config = new Config();
//redis://127.0.0.1:7181
//可以用"rediss://"来启用 SSL 连接
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redisson = Redisson.create(config);
/**
 * redisson配置
 *
 * @Author: yichangqiao
 * @Date: 2024/1/7 15:24
 */
@Configuration
public class RedissonConfig {

    /**
     * 对所有的Redisson的操作都是使用RedissonClient对象
     *
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        // redis:// 为redis地址，如果redis开启SSL链接，需要使用rediss://
        config.useSingleServer().setAddress("redis://127.0.0.1:6379")
        .setPassword("123456").setDatabase(3);
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }

}

(四) 使用分布式锁

redisson提供了很多种类型的锁，一般是使用的可重入锁。

RLock lock = redisson.getLock("anyLock");// 最常见的使用方法
lock.lock();
// 加锁以后 10 秒钟自动解锁// 无需调用 unlock 方法手动解锁
lock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待 100 秒，上锁以后 10 秒自动解锁 boolean res = lock.tryLock(100,
10, TimeUnit.SECONDS);
if (res) {
    try {
        ...
    } finally {
        lock.unlock();
    }
}
  /**
     * 测试redisson分布式锁
     */
    @GetMapping("/testRedisson")
    public JsonResult testRedisson() {
        // 1.获取一把锁，保证获取的是同一把锁就行。
        RLock lock = redissonClient.getLock("my-lock");
        // 2.加锁 (阻塞式等待，默认加的锁都是30S时间)
        lock.lock(30, TimeUnit.SECONDS);
        // 锁的自动续期，如果业务超长，运行期间自动给锁续上新的30S，不用担心业务时间过长，锁自动过期被删除。
        // 加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30S以后自动删除。
        try {
            log.info("加锁成功，执行业务：{}", LocalDateTime.now());
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 解锁，假设解锁代码没有运行，redisson会不会出现死锁。
            // 如果设置了锁的过期时间不会，否则会出现。
            log.info("释放锁：{}", Thread.currentThread().getId());
            lock.unlock();
        }
        return ResultUtil.success("success");
    }

(五) 使用其他

可以参照官方文档进行

五、Lock看门狗原理

先看一下以下的代码逻辑：

lock.lock(30, TimeUnit.SECONDS);
// 30秒自动解锁，自动解锁的时间一定要大于业务的执行时间。
// 问题：lock.lock(30, TimeUnit.SECONDS);
// 到了锁的自动到期时间之后，业务代码还没执行完，锁不会自动续期。

上述代码在执行时间到了之后，不会给锁自动续期。手动指定了过期时间后，在底层与看门狗的自动续期走了不同的方法：

看门狗的方法中有一个更新过期时间的定时任务，并且每隔三分之一的看门狗过期时间，就会执行一次，续期30S，看门狗的默认过期时间就是30S。

总结：

  1. 加锁 (阻塞式等待，默认加的锁都是30S时间)。
  2. lock.lock(30, TimeUnit.SECONDS); 指定30秒自动解锁，自动解锁时间一定要大于业务的执行时间。
  3. 如果指定了锁的超时时间，就发送给redis执行脚本进行占锁，默认超时时间为指定时间。
  4. lock.lock(30, TimeUnit.SECONDS); 在锁到期之后，不会自动续期。
  5. 锁的自动续期，如果业务超长，运行期间自动给锁续上了新的30S，不用担心业务时间长，锁自动过期被清理掉。
  6. 如果没有指定锁的超时时间，就使用30 * 1000【LockWatchdogTimeOut】看门狗的默认时间。
  7. 只要占锁成功，就会自动一个定时任务，重新给锁设置过期时间，新的过期时间就是看门狗的默认时间，每隔10S自动续期。

六、读写锁

(一) 测试

@GetMapping("/writeValue")
public JsonResult writeValue() {
    RReadWriteLock lock = redissonClient.getReadWriteLock("rw-lock");
    String s = "";
    RLock rLock = lock.writeLock();
    try {
        // 改数据加写锁，读数据加读锁
        rLock.lock();
        s = UUID.randomUUID().toString();
        Thread.sleep(20000);
        redisTemplate.opsForValue().set("writeValue", s);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        rLock.unlock();
    }
    return ResultUtil.success(s);
}

@GetMapping("/readValue")
public JsonResult readValue() {
    RReadWriteLock lock = redissonClient.getReadWriteLock("rw-lock");
    String s = "";
    // 加读锁
    RLock rLock = lock.readLock();
    try {
        rLock.lock();
        Thread.sleep(20000);
        s = redisTemplate.opsForValue().get("writeValue");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
    }
    return ResultUtil.success(s);
}

(二) 补充

  1. 保证一定能读到最新数据，修改期间，写锁是一个排他锁（互斥锁、独享锁）。读锁是一个共享锁。
  2. 写锁没释放读就必须等待。
  3. 读 + 读：相当于无锁，并发读，只会在redis中记录号所有当前的读锁，他们都会同时加锁成功。
  4. 写 + 读：等待写锁释放。
  5. 写 + 写：阻塞方式。
  6. 读 + 写：有读锁，写也需要等待。
  7. 是要有写的存在都必须等待。

七、闭锁

@GetMapping("/lockDoor")
public JsonResult lockDoor() {
    RCountDownLatch door = redissonClient.getCountDownLatch("door");
    try {
        door.trySetCount(5);
        door.await(); // 等待锁全部完成
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    return ResultUtil.success("放假了。。。。");
}

@GetMapping("/gogogo/{id}")
public JsonResult gogogo(@PathVariable("id") Long id) {
    RCountDownLatch door = redissonClient.getCountDownLatch("door");
    door.countDown(); // 计数减一
    return ResultUtil.success(id + "班的人都走了...");
}

八、信号量

/**
     * 信号量测试
     */
@GetMapping("/park")
public JsonResult park() {
    RSemaphore park = redissonClient.getSemaphore("park");
    //        park.acquire(); // 获取一个信号，获取一个值，占一个车位
    boolean b = park.tryAcquire();
    return ResultUtil.success("ok =>" + b);
}

@GetMapping("/go")
public JsonResult go() {
    RSemaphore park = redissonClient.getSemaphore("park");
    park.release(); // 释放一个车位
    return ResultUtil.success("ok");
}

信号量也可以用作限流：

/**
     * 信号量测试
     * 也可以用作分布式限流，例如：车库停车
     */
@GetMapping("/park")
public JsonResult park() {
    RSemaphore park = redissonClient.getSemaphore("park");
    //        park.acquire(); // 获取一个信号，获取一个值，占一个车位
    boolean b = park.tryAcquire();
    if (b) {
        // 执行业务

    } else {
        return ResultUtil.fail("error");
    }
    return ResultUtil.success("ok =>" + b);
}

@GetMapping("/go")
public JsonResult go() {
    RSemaphore park = redissonClient.getSemaphore("park");
    park.release(); // 释放一个车位
    return ResultUtil.success("ok");
}

网络深处的易某某
关注
  • 26
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redisson
Meiko记录
06-23 942
如果你之前是在用 Redis 的话，那使用 Redisson 的话将会事半功倍，Redisson 提供了使用 Redis的最简单和最便捷的方法。 Redisson的宗旨是促进使用者对 Redis 的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。 Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。 Netty 框架：Redisson采用了基于NIO的Netty框架
redisson使用手册
01-19
Redisson是一款基于Java的Redis客户端，它提供了丰富的数据结构支持，如锁、信号量、队列、布隆过滤器等，极大地扩展了Redis在Java应用中的功能。本使用手册将详细解析Redisson的使用方法和功能，帮助开发者充分利用...
Springboot中使用redisson + 自定义注解优雅的实现消息的发布订阅
热门推荐
qq_35716689的博客
01-18 46万+
在一些小型场景下，使用mq中间件可能会为原有项目增加不少维护成本，使用redisson实现消息的收发是个不错的选择。作者：鼠鼠我捏，要死了捏
Redisson详解
m0_59679869的博客
06-15 1275
Redisson不只是简单地对Redis进行了封装，它还提供了一系列高级的分布式Java数据结构，像是分布式锁、原子长整型这种。
Redisson-获取连接原理
fl_zxf的专栏
06-17 254
# Redisson-获取连接原理
Redisson入门
梦清尘的博客
06-30 4236
一、Redisson是什么？ 二、使用步骤 1.引入库 2.Redisson 配置 2.增（改） 3.删 4.查 5.测试类 三、遇到错误（ERROR org.redisson.client.handler.CommandDecoder - Unable to decode data. channel） 总结 参考资料
Redisson-CommandAsyncExecutor-原理
fl_zxf的专栏
06-18 450
# Redisson-CommandAsyncExecutor-原理
Redisson与SpringBoot整合
抽象的螺旋
12-13 1万+
概述 官方解释，什么是redisson？ Redis Java Client with features of In-Memory Data Grid。 什么是redisson
Redisson的基本使用
学习记录和总结
11-17 1万+
Redisson的基本使用：可重入锁、读写锁、信号量、闭锁
Redis Stream & Redisson Stream
罗小爬的技术宝书
06-27 1231
子命令式可选的，表示无需确认消息，NOACK子命令适用于对可靠性要求不高、偶尔的消息丢失是可以接受的情况，使用NOACK子命令可以避免将消息添加到PEL（ Pending Entries List），相当于在读取消息后自动确认消息，后续无需再调用XACK命令进行确认，通过XPENDING查询出PEL消息（已投递未确认）后，若原先消息对应的consumer已经挂掉，没有能力继续处理消息，则可通过XCLIAM将对应的消息转移给同分组下的其他consumer进行处理，
使用redisson替代jedis
06-22
### 使用Redisson替代Jedis 在分布式系统中，Redis作为一种高性能的键值存储数据库，被广泛应用于缓存、消息队列、数据同步等场景。在Java开发领域，开发者可以选择多种客户端来与Redis进行交互，其中最常用的是...
redisson lock和tryLock 分布式锁简单练习
01-10
redisson lock和tryLock 分布式锁简单练习
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....
springboot - 2.7.3版本 - （四）整合Redisson
09-23
在redis的基础上添加redisson的使用，主要演示与springboot项目的整合
WPF中XAML相对路径表示方法
以梦为马 不负韶华
08-14 381
在WPF XAML中，相对路径是一种非常实用的方式来引用资源文件，如图像、样式表和其他XAML文件。相对路径可以帮助您构建更加灵活和可移植的应用程序，因为它允许资源文件的位置相对于XAML文件的位置进行定位。
WPF参考做的TextBox圆角，并且水印文字操作
weixin_40029679的博客
08-09 237
1.首先进行 转换器操作（获取当前Textbox Text是否为空或者空格）其中水印 就是附加属性 设定的text ，Tag则单位的显示数据。但是因为转换类是在其他方法内，所以此地需要引入操作。4 应用在界面的xaml下的操作：引入Key。使用附加属性操作水印建议推荐先拜读这篇文章。引入的写法和xaml标准方法： 引入地址。使用圆角以及水印加入单位推荐拜读这个。
WPF窗体动态效果
最新发布
zhaotianff的专栏
08-14 1008
WPF实现窗体动态效果，类似网页上的动态背景效果。
WPF篇（13）-ScrollViewer控件+ScrollBar滚动条+Slider滑动条
一个人的江湖
08-09 1222
如果某个控件的尺寸太大，当前界面无法全部显示，则可以将这个控件包含在ScrollViewer中，因为ScrollViewer控件封装了一个水平滚动条ScrollBar和一个垂直滚动条ScrollBar，所以，ScrollViewer就是一个包含其它可视元素的可滚动区域控件。ScrollViewer继承于ContentControl，所以它也是一个内容控件，只能在Content属性中设置一个子元素，如果要在ScrollViewer中显示多个子元素，请设置一个集合控件。 ScrollViewer 控件既响应鼠标
redissonLock
06-07
redissonLock是基于Redis分布式锁的实现。它是一个Java框架，提供了一些分布式的Java对象和服务，例如分布式对象、分布式集合、分布式锁等等。redissonLock的分布式锁提供了可重入锁、公平锁、联锁等多种锁。 在Java代码中使用redissonLock分布式锁进行加锁和解锁的示例如下所示： 1. 加锁示例 ```java RLock lock = redissonClient.getLock("myLock"); lock.lock(); try { // 线程安全操作 } finally { lock.unlock(); } ``` 2. 解锁示例 ```java RLock lock = redissonClient.getLock("myLock"); lock.unlock(); ``` 需要注意的是，为了保证可靠性，加锁和解锁的操作必须在同一个Redisson客户端中进行。 如果要使用redissonLock分布式锁，需要将其引入到项目的依赖中，示例如下： ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.11.6</version> </dependency> ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值