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
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值