今天小編給大家分享一下Java-Redis-Redisson分布式鎖的功能如何使用及實現的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。
Java-Redis-Redisson配置基礎上我們進行了改造,讓鎖的使用更加方便
RedissonLock
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedissonLock {
int lockTime() default 3; //加鎖的時間默認3秒, 如果任務在3秒內執行完畢那么自動釋放鎖,如果任務3秒內沒有執行完畢也會釋放鎖, 所以內容執行時間過長適當加大鎖的時間
String key() default "" ; //唯一標識,如果沒有那么默認為token->sessionId
String doc() default "重復提交請求,請稍后再試";
boolean repeatLock() default false; //可重復加鎖直到加鎖成功,默認為false不能重復加鎖
int repeatLockCount() default -1; //可重復加鎖限制加鎖的次數, 默認-1直到成功,設置10那么加鎖10次都沒成功就直接返回
int lockWaitTimeMs() default 100; //重復加鎖默認的阻塞時間100毫秒,可以自己定義
}RepeatSubmitAspect
import com.application.Result;
import com.commonutils.NullUtils;
import com.redis.utils.DistributedRedisLock;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
@Aspect
@Component
public class RepeatSubmitAspect {
@Value("${spring.redis.redisson.tokenName}")
private String tokenName;
@Autowired
private DistributedRedisLock redisLock;
@Pointcut("@annotation(noRepeatSubmit)")
public void pointCut(RedissonLock noRepeatSubmit) {
}
public static HttpServletRequest getRequest() {
ServletRequestAttributes ra= (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
return ra.getRequest();
}
@Around("pointCut(noRepeatSubmit)")
public Object around(ProceedingJoinPoint pjp, RedissonLock noRepeatSubmit) throws Throwable {
int lockSeconds = noRepeatSubmit.lockTime();
String doc = noRepeatSubmit.doc();
String keyName = noRepeatSubmit.key();
boolean b = noRepeatSubmit.repeatLock();
int repeatLockCount = noRepeatSubmit.repeatLockCount();
int lockWaitTimeMs = noRepeatSubmit.lockWaitTimeMs();
HttpServletRequest request = getRequest();
Assert.notNull(request, "request can not null");
//如果沒有唯一表示那么就使用token或者sessionID來唯一表示
if(!NullUtils.notEmpty(keyName)){
String token = request.getHeader(tokenName);
if(NullUtils.notEmpty(token)){
keyName=token;
}else{
//使用sessionID (注意保證分布式session共享)
keyName = request.getSession().getId();
}
System.out.println("tokenName:"+keyName);
}
String path = request.getServletPath();
String key = getKey(keyName, path);
//加鎖
boolean isSuccess = redisLock.acquire(key, lockSeconds,b,repeatLockCount,lockWaitTimeMs);
if (isSuccess) {
// 獲取鎖成功
Object result;
try {
// 執行
result = pjp.proceed();
} finally {
// 解鎖
redisLock.release(key);
}
return result;
} else {
// 獲取鎖失敗，認為是重復提交的請求
return Result.Error(doc);
}
}
private String getKey(String token, String path) {
return token + path;
}
}DistributedRedisLock
/**
* 簡要描述
*
* @Author: huanmin
* @Date: 2022/8/1 17:39
* @Version: 1.0
* @Description: 文件作用詳細描述....
*/
import com.multithreading.utils.SleepTools;
import lombok.SneakyThrows;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class DistributedRedisLock {
private static final Logger logger = LoggerFactory.getLogger(DistributedRedisLock.class);
//從配置類中獲取redisson對象
@Autowired
private RedissonClient redissonClient;
private final String LOCK_TITLE = "redisLock_";
private final ThreadLocal<Integer> count = new ThreadLocal<>();//計數
//加鎖 , 線程加鎖的時候發現,鎖有人用了 ,那么就會進入自旋等待
@SneakyThrows
public boolean acquire(String lockKey, long seconds, boolean repeatLock, int repeatLockCount, int lockWaitTimeMs) {
count.set(0); //初始化值
//獲取鎖對象
RLock mylock = redissonClient.getLock((LOCK_TITLE + lockKey));
do {
//嘗試加鎖
boolean b = mylock.tryLock(0, seconds, TimeUnit.SECONDS);;
if (b) {
logger.info("獲取鎖成功");
return true;
}
logger.info("嘗試獲取鎖" + Thread.currentThread().getName());
//獲取加鎖的次數,如果是-1那么持續加鎖,如果滿足加鎖次數那么結束加鎖
if (repeatLockCount != -1 && count.get().equals(repeatLockCount)) {
logger.warn(Thread.currentThread().getName() + "嘗試加鎖失敗以嘗試了:" + count.get() + "次");
return false;
}
SleepTools.ms(lockWaitTimeMs);
//加鎖次數增加
count.set(count.get() + 1);
} while (repeatLock);
logger.warn("重復提交");
return false;
}
//手動鎖的釋放
public void release(String lockKey) {
//獲取所對象
RLock mylock = redissonClient.getLock((LOCK_TITLE + lockKey));
// 這里判斷下當前key是否上鎖，不然業務執行時間大于鎖自動釋放時間后，解鎖報異常
if (mylock.isLocked()&&mylock.isHeldByCurrentThread()) { // 是否還是鎖定狀態并且鎖是當前線程的
mylock.unlock(); // 釋放鎖
logger.info("解鎖:" + lockKey);
}
}
}支持配置鎖的時間
支持配置鎖的key(同一個key的請求會被鎖住)
支持重復加鎖
支持重復加鎖的次數
支持重復加鎖的間隔時間
通過以上功能的的組合能做到,冪等性,分布式悲觀鎖, 超時丟棄 ,不止在Controller里使用,而是在任何基于Spring容器管理的Bean都支持,當然如果特殊的場景我們可以直接使用DistributedRedisLock類,注意在任何時候都要釋放鎖
/***
*默認加鎖3秒
* 加鎖的key為token->sessionId
* 加鎖失敗不可重復加鎖
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock
@GetMapping(value = "/updateAgeAsyncLock" )
public Result updateAgeAsyncLock() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖3秒
* 加鎖失敗不可重復加鎖
* 加鎖的key為token->sessionId
* 提示: 加鎖失敗
*/
@RedissonLock(doc = "加鎖失敗")
@GetMapping(value = "/updateAgeAsyncLockDoc" )
public Result updateAgeAsyncLockDoc() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖15秒
* 加鎖失敗不可重復加鎖
* 加鎖的key為token->sessionId
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock(lockTime = 15)
@GetMapping(value = "/updateAgeAsyncLock0" )
public Result updateAgeAsyncLock0() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖15秒
* 加鎖失敗不可重復加鎖
* 加鎖的key為updateAgeAsyncLock
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock(lockTime = 15,key = "updateAgeAsyncLock")
@GetMapping(value = "/updateAgeAsyncLock1" )
public Result updateAgeAsyncLock1() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖15秒
* 加鎖失敗可重復加鎖,直到加鎖成功
* 加鎖的key為updateAgeAsyncLock
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true)
@GetMapping(value = "/updateAgeAsyncLock2" )
public Result updateAgeAsyncLock2() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖15秒
* 加鎖失敗可重復加鎖10次,每次默認間隔100毫秒
* 加鎖的key為updateAgeAsyncLock
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true,repeatLockCount = 10)
@GetMapping(value = "/updateAgeAsyncLock3" )
public Result updateAgeAsyncLock3() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖15秒
* 加鎖失敗可重復加鎖10次,每次默認間隔500毫秒
* 加鎖的key為updateAgeAsyncLock
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true,repeatLockCount = 10,lockWaitTimeMs = 500)
@GetMapping(value = "/updateAgeAsyncLock4" )
public Result updateAgeAsyncLock4() {
userService.updateAgeAsyncLock();
return Result.Ok();
}
/***
* 默認加鎖15秒
* 加鎖失敗可重復加鎖,直到成功,每次嘗試間隔500毫秒
* 加鎖的key為updateAgeAsyncLock
* 默認提示: 重復提交請求,請稍后再試
*/
@RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true,lockWaitTimeMs = 500)
@GetMapping(value = "/updateAgeAsyncLock4" )
public Result updateAgeAsyncLock4() {
userService.updateAgeAsyncLock();
return Result.Ok();
}驗證方式: 使用jmeter多線程10000請求 ,注意使用jmeter的時候不要使用默認鎖key的方式,因為jmeter每次請sessionID都不同的,想要驗證效果我們需要手動加key或者使用token
public class DistributedRedisLock {
//從配置類中獲取redisson對象
@Autowired
private RedissonClient redissonClient;
private final String LOCK_TITLE = "redisLock_";
//加鎖 , 線程加鎖的時候發現,鎖有人用了 ,那么就會進入自旋等待
public boolean acquire(String lockName){
//聲明key對象
String key = LOCK_TITLE + lockName;
//獲取鎖對象
RLock mylock = redissonClient.getLock(key);
//一直等待直到加鎖成功后，并且設置鎖過期時間，防止死鎖的產生
mylock.lock(10, TimeUnit.SECONDS);
System.err.println("======lock======"+Thread.currentThread().getName());
//加鎖成功
return true;
}
//鎖的釋放
public void release(String lockName){
//必須是和加鎖時的同一個key
String key = LOCK_TITLE + lockName;
//獲取所對象
RLock mylock = redissonClient.getLock(key);
// 這里判斷下當前key是否上鎖，不然業務執行時間大于鎖自動釋放時間后，解鎖報異常
if(mylock.isLocked()){ // 是否還是鎖定狀態
if(mylock.isHeldByCurrentThread()){ // 時候是當前執行線程的鎖
mylock.unlock(); // 釋放鎖
System.err.println("======unlock======"+Thread.currentThread().getName());
}
}
}
}以上就是“Java-Redis-Redisson分布式鎖的功能如何使用及實現”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
