redisson的知识点

编程小菜吉

已于 2022-11-16 13:32:56 修改

阅读量871

点赞数

分类专栏： Redis 文章标签： java

于 2022-11-16 13:29:29 首次发布

本文链接：https://blog.csdn.net/EnjoyFight/article/details/127879186

版权

Redis 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

redisson的知识点

一、初识redisson
二、redisson的基本使用

一、初识redisson

1、场景分析

我们要对一个产品进行大促抢购，在高并发的场景下，我们可以看出当多个线程同时操作的时候，我们无法保证它的并发安全性。

2、加入 synchronized 同步锁

这是我们在单机模式下遇到并发安全问题首先想到的办法，但是synchronized 同步锁是基于jvm的，不能解决集群环境的并发安全问题

3、加入setnx锁

通过之前的学习可知，redis为我们提供了一个分布式锁setnx，即为一个key加锁，如果成功则返回1，否则返回0，代码如下：

@Autowired
private StringRedisTemplate stringRedisTemplate;

@RequestMapping("/deduct_stock")
public void deductStock() {
    String lockKey = "product_101";
    // 就相当于 setnx 这个命令，设置一个key-value，相当于锁
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "lock");
    // 没有获取到锁，就直接返回
    if (!result) {
         return "error_code";
     }
    // 执行 get 命令，取出 stock 这个 key 的 value
    int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
    if (stock > 0) {
        int realStock = stock - 1;
        // 执行 set 命令，设置 stock 这个 key 的 value
        stringRedisTemplate.opsForValue().set("stock", realStock + "");
        System.out.println("扣减成功，剩余库存:" + realStock);
    } else {
        System.out.println("扣减失败，库存不足");
    }
    // 删除上面业务逻辑执行前设置的key-value。
    stringRedisTemplate.delete(lockKey);
}

问题：如果在业务逻辑执行的过程中发生了异常或者宕机，那么这个锁就永远不会被删除掉了。

4、加入try-catch-finally和锁过期时间

（1）try-catch-finally避免了在业务逻辑处理时抛出异常以及最终锁的消除
（2）加入锁的过期时间是防止在加上分布式锁之后，突然宕机的情况。

@Autowired
private StringRedisTemplate stringRedisTemplate;

@RequestMapping("/deduct_stock")
public void deductStock() {
    String lockKey = "product_101";
    /*// 就相当于 setnx 这个命令
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "lock");
    // 设置锁的过期时间为10s
    stringRedisTemplate.expire(lockKey, 10, TimeUnit.SECONDS);*/
    // 上面的这两个命令可能也在第一个设置完锁之后，还没有设置过期时间呢，就发生了宕机
    // 结果锁就无法释放了，可以改成下面行，将两行代码合并了，是一个原子操作
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "lock", 30, TimeUnit.SECONDS);
    // 没有获取到锁，就直接返回
    if (!result) {
         return "error_code";
     }
    // 执行 get 命令，取出 stock 这个 key 的 value
    try{
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if (stock > 0) {
            int realStock = stock - 1;
            // 执行 set 命令，设置 stock 这个 key 的 value
            stringRedisTemplate.opsForValue().set("stock", realStock + "");
            System.out.println("扣减成功，剩余库存:" + realStock);
        } else {
            System.out.println("扣减失败，库存不足");
        }
    }finally {
        // 在 finally 中执行锁的消除，无论发不发生异常，都可以执行到这一行
        stringRedisTemplate.delete(lockKey);
    }
}

问题：现在我们设置的锁失效的时间是10s，但是现在有一个线程t1执行一个任务需要的时间是15s，那么当t1在执行到10时，这段业务逻辑的中间时，锁就已经失效了，此时线程t2发现可以加锁了，就直接给上面加锁，假设t2执行需要15s（只要是5s以上就行），当t2执行到5s时，t1执行完了，这时t1去释放锁，但是释放的是t2的锁，以此类推，就会发现当大量线程进来的时候，可能每个人释放的都不是自己的锁，就会产生很大的问题。

5、加入UUID作为分布式锁的唯一标识

刚才我们出现了锁错乱释放的情况，现在我们在设置分布式锁的时候将它的value值换成一个UUID，这样，每个线程加的锁就是唯一的了，在释放锁的时候拿出相应的value值先去判断一下，如果是自己加的就释放，如果不是，就不能释放，这样就不会出现锁错乱释放的那种情况了。

@Autowired
private StringRedisTemplate stringRedisTemplate;

@RequestMapping("/deduct_stock")
public void deductStock() {
    String lockKey = "product_101";
    String clientId = UUID.randomUUID().toString();
    // 上面的这两个命令可能也在第一个设置完锁之后，还没有设置过期时间呢，就发生了宕机
    // 结果锁就无法释放了，可以改成下面行，将两行代码合并了，是一个原子操作
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, clientId, 30, TimeUnit.SECONDS);
    // 执行 get 命令，取出 stock 这个 key 的 value
    try{
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if (stock > 0) {
            int realStock = stock - 1;
            // 执行 set 命令，设置 stock 这个 key 的 value
            stringRedisTemplate.opsForValue().set("stock", realStock + "");
            System.out.println("扣减成功，剩余库存:" + realStock);
        } else {
            System.out.println("扣减失败，库存不足");
        }
    }finally {
        // 获取到当前的 value 值，看是否是之前生成的 UUID
        if (clientId.equals(stringRedisTemplate.opsForValue().get(lockKey))) {
            // 在 finally 中执行锁的消除，无论发不发生异常，都可以执行到这一行
            stringRedisTemplate.delete(lockKey);
        }
    }
}

问题：解决掉了锁的错乱释放，但是还是没有解决，t1还没有执行完呢，锁就被释放了，t2就已经加入进来了，还是会线程不安全，以及在最后释放锁的时候，判断value以及释放锁的两步操作也不是原子性的，所以也可能中间出现宕机问题。

6、增加锁续命功能控制一次只能有一个线程访问资源

当某个线程给某个资源加锁成功后，会开启一个定时任务，这个定时任务会以指定现成的1/3为周期去循环调用，如果判断线程还存在，就将过期时间重置，如果判断线程已经不存在，就将定时任务这个线程删掉。

这里采用redisson工具去实现该功能

@Autowired
    private Redisson redisson;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/deduct_stock")
    public String deductStock() {

        try {
            // 加锁，并实现锁续命
            redissonLock.lock();
            // 执行 get 命令，取出 stock 这个 key 的 value
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if (stock > 0) {
                int realStock = stock - 1;
                // 执行 set 命令，设置 stock 这个 key 的 value
                stringRedisTemplate.opsForValue().set("stock", realStock + "");
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        } finally {
            redissonLock.unlock();
        }

        return "end";
    }

总结：以上的这些是我们使用redis实现分布式锁的所存在的问题，但是redisson已经帮我们解决了

二、redisson的基本使用

1、概述

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。

Redisson和jedis以及lettuce一样都是redis客户端，只不过Redisson功能更强大。

在这里插入图片描述

2、搭建环境

2.1、引入相关的依赖

<!-- 以后使用redisson作为所有分布式锁，分布式对象等功能框架-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.12.0</version>
</dependency>

2.2、配置redisson，程序化的配置方法是通过构建Config对象实例来实现

@Configuration
public class MyRedissonConfig {

    //注册RedissonClient对象
    @Bean(destroyMethod="shutdown")
    RedissonClient redisson() throws IOException {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.182.150:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

3、可重入锁（Reentrant Lock）

@ResponseBody
@GetMapping("/hello")
public String hello(){
    //获取一把锁
    RLock lock = redissonClient.getLock("my-lock");

    //加锁
    lock.lock();
    //锁的自动续期，如果业务执行时间超长，运行期间会自动给锁续期30秒时间，不用担心业务时间长，锁自动过期
    //加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30秒后也会自动删除
    try {
        System.out.println("加锁成功，执行业务.... "+Thread.currentThread().getId());
        Thread.sleep(30000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        //手动解锁
        System.out.println("解锁..."+Thread.currentThread().getId());
        lock.unlock();
    }
    return "hello";
}

（1）加锁操作：lock.lock()

没有指定锁的过期时间，就是默认为30s，即看门狗的默认时间，只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】，每隔10s（过期时间的1/3）就会自动续期到30秒,也可以通过修改Config.lockWatchdogTimeout来另行指定。

（2）加锁操作：lock.lock(10, TimeUnit.SECONDS)

默认锁的过期时间就是我们指定的时间

4、读写锁

基于Redis的Redisson分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。其中读锁和写锁都继承了RLock接口。
分布式可重入读写锁允许同时有多个读锁和一个写锁处于加锁状态。
（1）读锁

@GetMapping("/read")
public String readValue(){
    RReadWriteLock lock = redissonClient.getReadWriteLock("rw-lock");
    String s = "";
    //加读锁
    RLock rLock = lock.readLock();
    rLock.lock();
    try {
        System.out.println("读锁加锁成功"+Thread.currentThread().getId());
        s = redisTemplate.opsForValue().get("writeValue");
        Thread.sleep(30000);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
        System.out.println("读锁释放"+Thread.currentThread().getId());
    }
    return  s;
}

（2）写锁

@GetMapping("/write")
public String writeValue(){
    // 获取一把锁
    RReadWriteLock lock = redissonClient.getReadWriteLock("rw-lock");
    String s = "";
    // 加写锁
    RLock rLock = lock.writeLock();
    try {
        //1、改数据加写锁，读数据加读锁
        rLock.lock();
        System.out.println("写锁加锁成功..."+Thread.currentThread().getId());
        s = UUID.randomUUID().toString();
        Thread.sleep(30000);
        redisTemplate.opsForValue().set("writeValue",s);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
        System.out.println("写锁释放"+Thread.currentThread().getId());
    }
    return  s;
}

案例：
①先加写锁，后加读锁：此时并不会立刻给数据加读锁，而是需要等待写锁释放后，才能加读锁
②先加读锁，再加写锁：有读锁，写锁需要等待
③先加读锁，再加读锁：并发读锁相当于无锁模式，会同时加锁成功
④先加写锁，再加写锁：第一个加锁成功，第二个失败
总结：只要有写锁的存在，都必须等待，写锁是一个排他锁，只能有一个写锁存在，读锁是一个共享锁，可以有多个读锁同时存在。

5、信号量（Semaphore）

基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法

RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
//或
semaphore.acquireAsync();
semaphore.acquire(23);
semaphore.tryAcquire();
//或
semaphore.tryAcquireAsync();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
//或
semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
//或
semaphore.releaseAsync();

6、闭锁（CountDownLatch）

基于Redisson的Redisson分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。

RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();

// 在其他线程或其他JVM里
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();

编程小菜吉

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
redisson的知识点

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。Redisson和jedis以及lettuce一样都是redis客户端，只不过Redisson功能更强大。
复制链接

扫一扫