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();