RLock fairLock = redisson.getFairLock("anyLock");
// 最常见的使用方法
fairLock.lock();
// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
fairLock.lock(10, TimeUnit.SECONDS);
// 尝试加锁,最多等待3秒,上锁以后10秒自动解锁
boolean res = fairLock.tryLock(3, 10, TimeUnit.SECONDS);
fairLock.unlock();
1.引入jar
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>2.14.0</version> <!-- 根据实际情况选择版本 -->
</dependency>
2.配置文件有多种方式
下面是我选择的方式之一:
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RedissonConfig {
@Value("${spring.redis.host}") // 获取 Redis 主机地址
private String redisHost;
@Value("${spring.redis.port}") // 获取 Redis 端口
private int redisPort;
@Value("${spring.redis.password}") // 获取 Redis 密码(如果有)
private String redisPassword;
@Bean
public RedissonClient redissonClient() {
Config config = new Config();
// 配置单节点模式
config.useSingleServer()
.setAddress("redis://" + redisHost + ":" + redisPort) // 设置 Redis 地址
.setPassword(redisPassword); // 设置 Redis 密码
// 创建 Redisson 客户端
return Redisson.create(config);
}
工具类
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* 分布式锁实现基于Redisson
*
* @date 2024-04-30
*/
@Slf4j
@Component
public class RedissonLockClient {
@Autowired
private RedissonClient redissonClient;
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 获取锁
*/
public RLock getLock(String lockKey) {
return redissonClient.getLock(lockKey);
}
/**
* 加锁操作
*
* @return boolean
*/
public boolean tryLock(String lockName, long expireSeconds) {
return tryLock(lockName, 0, expireSeconds);
}
/**
* 加锁操作
*
* @return boolean
*/
public boolean tryLock(String lockName, long waitTime, long expireSeconds) {
RLock rLock = getLock(lockName);
boolean getLock = false;
try {
getLock = rLock.tryLock(waitTime, expireSeconds, TimeUnit.SECONDS);
if (getLock) {
log.info("获取锁成功,lockName={}", lockName);
} else {
log.info("获取锁失败,lockName={}", lockName);
}
} catch (InterruptedException e) {
log.error("获取式锁异常,lockName=" + lockName, e);
getLock = false;
}
return getLock;
}
public boolean fairLock(String lockKey, TimeUnit unit, int leaseTime) {
RLock fairLock = redissonClient.getFairLock(lockKey);
try {
boolean existKey = existKey(lockKey);
// 已经存在了,就直接返回
if (existKey) {
return false;
}
return fairLock.tryLock(3, leaseTime, unit);
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
}
public boolean existKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 锁lockKey
*
* @param lockKey
* @return
*/
public RLock lock(String lockKey) {
RLock lock = getLock(lockKey);
lock.lock();
return lock;
}
/**
* 锁lockKey
*
* @param lockKey
* @param leaseTime
* @return
*/
public RLock lock(String lockKey, long leaseTime) {
RLock lock = getLock(lockKey);
lock.lock(leaseTime, TimeUnit.SECONDS);
return lock;
}
/**
* 解锁
*
* @param lockName 锁名称
*/
public void unlock(String lockName) {
try {
redissonClient.getLock(lockName).unlock();
} catch (Exception e) {
log.error("解锁异常,lockName=" + lockName, e);
}
}
}
业务实现
logger.info("加锁任务开始!!!!" );
String key = "命名的锁";
// 公平加锁,lockTime后锁自动释放
boolean isLocked = false;
try { //加锁30秒
isLocked = redissonLockClient.fairLock(key, TimeUnit.SECONDS, 30);
if (isLocked) {
//处理业务
} else {
logger.info("操作频繁,请稍后在试" );
}
} catch (Exception e) {
logger.error("失败" + e.getMessage());
}finally{
//可以解锁,根据业务看 ,到时间也会过期
if (isLocked) {
redissonLockClient.unlock(key);
}
}