Redisson官方文档: https://github.com/redisson/redisson/wiki
简介：Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分 的利用了 Redis 键值数据库提供的一系列优势，基于 Java 实用工具包中常用接口，为使用者 提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工 具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式 系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。
一.简单使用
1、导入依赖
2、新建Redisson配置
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MyRedissonConfig {
/**
* 所有对Redisson的使用都是通过RedissonClient对象
* @return
*/
@Bean(destroyMethod = "shutdown")
public RedissonClient redissonClient(){
// 创建配置 指定redis地址及节点信息
Config config = new Config();
config.useSingleServer().setAddress("XXX.XX.XX.X(redis地址):端口").setPassword("xxxxxxxxx");
// 根据config创建出RedissonClient实例
RedissonClient redissonClient = Redisson.create(config);
return redissonClient;
}
}
3、测试
@Autowired
RedissonClient redissonClient;
@Test
void redisson(){
System.out.println(redissonClient);
}
运行测试代码发现控制台有异常，报错信息为 ：
java.lang.IllegalArgumentException: Redis url should start with redis:// or rediss:// (for SSL connection)
提示我们要在地址前加上redis:// ,SSL连接则需要加上rediss：//
所以需要改为setAddress("redis://XXX.XX.XX.X:6379")即可
打印结果：
org.redisson.Redisson@6159fb3c
二.分布式锁
1、可重入锁
基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
常用代码：
RLock lock = redisson.getLock("anyLock");
// 最常见的使用方法
lock.lock();
测试代码：
@ResponseBody
@GetMapping("/hello")
public String hello() {
// 1.获取一把锁，只要锁的名字一样，就是同一把锁
RLock lock = redisson.getLock("my-lock");
lock.lock(); // 阻塞式等待。默认加的锁是30s时间
try {
// 1、锁的自动续期，运行期间自动给锁续上新的30s，无需担心业务时间长，锁过期会自动被释放
// 2、加锁的业务只要运行完成，就不会给当前锁续期，即使不手动释放锁，锁默认在30s后自动释放，避免死锁
System.out.println("加锁成功，执行业务代码..."+Thread.currentThread().getId());
Thread.sleep(30000);
} catch (Exception e) {
e.printStackTrace();
}finally {
System.out.println("释放锁..."+Thread.currentThread().getId());
lock.unlock();
}
return "Hello!";
}
结果：
加锁成功，执行业务代码...99
释放锁...99
可以发现，当我们的业务超长时，运行期间，redisson会为我们自动续期锁，业务执行完将不会续期，即使不手动释放锁，锁也会默认在30s后释放。
2、看门狗机制
redisson 中提供的续期机制
开一个监听线程，如果方法还没执行完，就帮你重置 redis 锁的过期时间。
原理：
启动定时任务重新给锁设置过期时间，默认过期时间是 30 秒，每 10 秒（看门狗默认事件的1/3）续期一次（补到 30 秒）如果线程挂掉（注意 debug 模式也会被它当成服务器宕机），则不会续期只有lock.lock(); 会有看门狗机制；lock.lock(10,,TimeUnit.SECONDS)；手动设置过期时间的话，则不会有看门狗机制（推荐）
3、读写锁
一次只有一个线程可以占有写模式的读写锁, 但是可以有多个线程同时占有读模式的读写锁.（该数据加写锁、读数据加读锁）
当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞. 当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行加锁, 它必须直到所有的线程释放锁.
测试读写锁代码：
@Autowired
RedissonClient redisson;
@Autowired
RedisTemplate redisTemplate;
@ResponseBody
@GetMapping("/write")
public String writeValue(){
RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");
RLock rLock = lock.writeLock();
String s = "";
try {
s = UUID.randomUUID().toString();
// 模拟业务时间
Thread.sleep(30000);
} catch (Exception e){
}finally {
rLock.unlock();
}
redisTemplate.opsForValue().set("writeValue",s);
return s;
}
@GetMapping(value = "/read")
@ResponseBody
public String readValue() {
String s = "";
RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
//加读锁
RLock rLock = readWriteLock.readLock();
try {
rLock.lock();
s = (String) redisTemplate.opsForValue().get("writeValue");
TimeUnit.SECONDS.sleep(10);
} catch (Exception e) {
e.printStackTrace();
} finally {
rLock.unlock();
}
return s;
}
当我们访问 localhost:10000/write写入数据时，因为线程睡眠了30s(模拟业务)，此时我们访问 localhost:10000/read 将会一直阻塞，等待写锁释放，读锁才能占锁从而获取执行业务。
4、信号量
信号量为存储在redis中的一个数字，当这个数字大于0时，即可以调用acquire()方法增加数量，也可以调用release()方法减少数量，但是当调用release()之后小于0的话方法就会阻塞，直到数字大于0。
可以应用于秒杀、限流等操作。
简单应用：
@GetMapping(value = "/park")
@ResponseBody
public String park() {
RSemaphore park = redisson.getSemaphore("park");
try {
park.acquire();// 获取一个信号量（redis中信号量值-1）,如果redis中信号量为0了，则在这里阻塞住，直到信号量大于0，可以拿到信号量，才会继续执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
return "ok";
}
@GetMapping(value = "/go")
@ResponseBody
public String go() {
RSemaphore park = redisson.getSemaphore("park");
park.release(); //释放一个信号量（redis中信号量值+1）
return "ok";
}
其中：redisson.getSemaphore("park").acquire() 当信号量为0时将会一直阻塞，直到信号量大于0，才会继续执行。但redisson.getSemaphore("park").tryAcquire() 将不会阻塞，能拿到信号量就返回true，否则返回false，lock.tryLock() 同理。
5、闭锁
在要完成某些运算时，只有其它线程的运算全部运行完毕，当前运算才继续下去。
模拟场景：
学校放假，学校门卫锁门必须等待所有班级全部离开，才将学校大门锁住。
@GetMapping(value = "/lockDoor")
@ResponseBody
public String lockDoor() throws InterruptedException {
RCountDownLatch lockDoor = redisson.getCountDownLatch("lockDoor");
lockDoor.trySetCount(5); // 设置计数为5
lockDoor.await(); //等待闭锁完成
return "放假啦...";
}
@GetMapping(value = "/go/{id}")
public String go(@PathVariable("id") Integer id) {
RCountDownLatch lockDoor = redisson.getCountDownLatch("lockDoor");
lockDoor.countDown(); // 计数减1
return id+"班都走光了";
}
结果：我们先访问 /lockDoor 线程将会阻塞，连续访问五次 /go/1 ，输出 放假了。
三.缓存数据一致性解决方案
尽量给锁加上过期时间；对于读写状态时，应该加上分布式读写锁。
推荐阅读
您阅读本篇文章共花了：
发表评论