首先关于redisson的介绍，这里就不搬运了，贴一下github原地址：
由于我这里只是简单使用了redisson的 分布式锁 的功能，这里仅记录下锁的简单使用。
官方文档：8.分布式锁和同步器
此次所用锁为可重入锁
8.1. 可重入锁（Reentrant Lock）
基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
RLock lock = redisson.getLock("anyLock");
// 最常见的使用方法
lock.lock();
复制代码
大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。
另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。
// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
try {
...
} finally {
lock.unlock();
}
}
复制代码
Redisson同时还为分布式锁提供了异步执行的相关方法：
RLock lock = redisson.getLock("anyLock");
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);
复制代码
RLock对象完全符合Java的Lock规范。也就是说只有拥有锁的进程才能解锁，其他进程解锁则会抛出IllegalMonitorStateException错误。但是如果遇到需要其他进程也能解锁的情况，请使用分布式信号量Semaphore 对象.
首先springboot整合redisson需要引入redisson的依赖：
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.13.6</version>
</dependency>
复制代码
亲测以上版本，配合springboot：2.2.5.RELEASE版本，正常使用。
单机版redis的配置文件跟原来springboot集成redis一样。
spring:
# Redis配置
redis:
timeout: 6000 # 连接超时时长（毫秒）
password: huauN@2021
database: 0
host: 192.168.104.64
port: 6379
#cluster:
#max-redirects: 3 # 获取失败 最大重定向次数
#nodes:
#- 192.168.104.101:6379
lettuce:
pool:
max-active: 1024 # 连接池最大连接数（默认为8，-1表示无限制 如果pool已经分配了超过max_active个jedis实例，则此时pool为耗尽）
max-wait: 10000 #最大等待连接时间，单位毫秒 默认为-1，表示永不超时，超时会抛出JedisConnectionException
max-idle: 10
min-idle: 5
复制代码Redis配置映射类 RedisConfigProperties.java
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Redis配置映射类
*
* @author linmengmeng
* @date 2021-03-11
**/
@Component
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfigProperties {
private Integer timeout;
private Integer database;
private Integer port;
private String host;
private String password;
private cluster cluster;
public static class cluster {
private List<String> nodes;
public List<String> getNodes() {
return nodes;
}
public void setNodes(List<String> nodes) {
this.nodes = nodes;
}
}
public Integer getTimeout() {
return timeout;
}
public void setTimeout(Integer timeout) {
this.timeout = timeout;
}
public Integer getDatabase() {
return database;
}
public void setDatabase(Integer database) {
this.database = database;
}
public Integer getPort() {
return port;
}
public void setPort(Integer port) {
this.port = port;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public RedisConfigProperties.cluster getCluster() {
return cluster;
}
public void setCluster(RedisConfigProperties.cluster cluster) {
this.cluster = cluster;
}
}
复制代码添加自动装配类：RedissonConfig.java
import gc.cnnvd.config.properties.RedisConfigProperties;
import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author linmengmeng
* @author 2021-08-30
*/
@Configuration
public class RedissonConfig {
@Autowired
private RedisConfigProperties redisConfigProperties;
/**
* redis://host:port
*/
private static final String REDIS_ADDRESS = "redis://%s:%s";
// /**
// * 集群模式-添加redisson的bean
// * @return
// */
// @Bean
// public Redisson redisson() {
// //redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
// List<String> clusterNodes = new ArrayList<>();
// for (int i = 0; i < redisConfigProperties.getCluster().getNodes().size(); i++) {
// clusterNodes.add("redis://" + redisConfigProperties.getCluster().getNodes().get(i));
// }
// Config config = new Config();
// ClusterServersConfig clusterServersConfig = config.useClusterServers()
// .addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
// clusterServersConfig.setPassword(redisConfigProperties.getPassword());//设置密码
// return (Redisson) Redisson.create(config);
// }
/**
* Redisson单机模式
* @return
*/
@Bean
public Redisson RedissonConfig(){
Config config = new Config();
// config.useSingleServer().setAddress("redis://localhost:6379").setDatabase(redisConfigProperties.getDatabase());
config.useSingleServer().setAddress(String.format(REDIS_ADDRESS, redisConfigProperties.getHost(), redisConfigProperties.getPort()))
.setDatabase(redisConfigProperties.getDatabase())
.setPassword(redisConfigProperties.getPassword());// 没有密码可以不设置
return (Redisson) Redisson.create(config);
}
}
复制代码
创建测试接口测试分布式锁：
package gc.cnnvd;
import gc.cnnvd.framework.common.api.ApiResult;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* @Auther linmengmeng
* @Date 2021-09-01 15:37
*/
@Slf4j
@RestController
@RequestMapping("/tourist")
public class TestRedissonLockController {
private static String FORMAT_LOCKKEY = "testLockKey:%s";//分布式锁的key
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private Redisson redisson;
@PostMapping("/testLock11")
public ApiResult<Boolean> testLock11() {
String lockKey = String.format(FORMAT_LOCKKEY, 3);
log.info("-------lockKey:{}", lockKey);
RLock lock = redisson.getLock(lockKey);
log.info("-------创建锁之后 isLocked-1:{}", lock.isLocked());
// try {
// Thread.sleep(10000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
Future<Boolean> res = lock.tryLockAsync(10, 30, TimeUnit.SECONDS);
log.info("-------tryLockAsync 后 isLocked-2:{}", lock.isLocked());
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (lock.isLocked()){
log.info("-------10秒 后----isLocked-3:{}", lock.isLocked());
//throw new BusinessException("测试获取锁后发生异常");
}
if (lock.isHeldByCurrentThread()){
log.info("-------isHeldByCurrentThread:{}", lock.isHeldByCurrentThread());
}
boolean result = false;
try {
result = res.get();
log.info("-------result:" + result);
if (result){
Thread.sleep(10000);
if (lock.isHeldByCurrentThread()){
log.info("-------isHeldByCurrentThread:{}", lock.isHeldByCurrentThread());
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}finally {
log.info("-------666666-------unlock-isLocked:{}", lock.isLocked());
if (lock.isLocked()){
log.info("-------88888888-------解锁解锁:{}", lock.isLocked());
lock.unlock();
}
}
log.info("res.get:{}", result);
return ApiResult.ok(lock.isLocked());
}
@PostMapping("/testLock12")
public ApiResult<Boolean> testLock12() {
String lockKey = String.format(FORMAT_LOCKKEY, 3);
log.info("====================lockKey:{}", lockKey);
RLock lock = redisson.getLock(lockKey);
log.info("====================isLocked-1:{}", lock.isLocked());
Future<Boolean> res = lock.tryLockAsync(5, 2, TimeUnit.SECONDS);
boolean locked = lock.isLocked();
log.info("====================isLocked-2:{}", locked);
if (locked){
if (lock.isHeldByCurrentThread()){
log.info("====================锁住了，是我的锁");
}else {
log.info("====================锁住了，不是我的锁");
}
}
Boolean getLock = null;
log.info("====================getLock-2:{}", getLock);
return ApiResult.ok(locked);
}
}
复制代码上面的代码看着很乱，当时摸索着打的日志，为了更好的理解加锁与解锁机制。
在 testLock11 接口里面添加线程睡眠，模仿程序运行占用锁，这时可以在redis里面看到我们加锁的key：
刚开始一直没有找到key，后来才发现，线程运行完成后，自动释放了锁，后面把睡眠时间拉长，才找到redis里面的key。
后面在用到代码里面，对加锁和锁的判断使用如下：
- 设置加锁的唯一标识
获取锁，并持有，做自己的业务逻辑
// 尝试获取锁-异步，第一个时间表示:最多等待时间，第二个时间参数表示:上锁以后多久自动解锁 Future<Boolean> res = lock.tryLockAsync(5, 5, TimeUnit.SECONDS); if (lock.isLocked() && lock.isHeldByCurrentThread()){ // 处理业务逻辑 // 解锁 if (lock.isLocked()){ lock.unlock(); } if (!lock.isLocked()){ log.info("解锁成功"); } return; } 复制代码
这里判断加锁我使用了：lock.isLocked() && lock.isHeldByCurrentThread()，这样可以确保只有一个线程进入锁的部分。
释放锁的时候，又加了一个判断：lock.isLocked()，避免由于业务逻辑耗时超过锁的自动释放时间，在执行lock.unlock();时，如果锁已经释放，或者别的线程拿到锁了，当前线程释放锁会抛出异常：
- 手动释放或者到期自动释放
2. 踩坑异常
1. Error processing condition on org.springframework.boot.autoconfigure.cache.S
首次添加redisson依赖后，原来的redis配置不好使了，项目启动就报了上面的错。最后切换实例化CacheManager
参考 SpringBoot通过Cacheable注解完成redis缓存功能
redisson入门可参考：# SpringBoot整合Redisson(单机版)
集群版配置文件可参考：redisson版本_SpringBoot整合Redisson(集群版)
2. o.redisson.client.handler.CommandsQueue : Exception occured. Channel:
刚开始由于使用了旧版本的redisson，发现项目启动后不久，控制台抛出此异常
参考：
切换redisson版本，解决此异常。
其他参考博客：
REDIS分布式锁REDISSON扩展 这篇博客结合AOP整合了redisson锁，值得学习下。
锁的相关概念，理解：分布式锁，redisson是如何解决死锁问题
如果翻到了最后，就再推荐一篇通俗易懂的博客: Spring Boot整合Redis实现简单的分布式锁 SpringBoot整合Redisson实现分布式锁