Java-Redis-Redisson分布式鎖的功能如何使用及實(shí)現(xiàn)

今天小編給大家分享一下Java-Redis-Redisson分布式鎖的功能如何使用及實(shí)現(xiàn)的相關(guān)知識(shí)點(diǎn)，內(nèi)容詳細(xì)，邏輯清晰，相信大部分人都還太了解這方面的知識(shí)，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

前置

Java-Redis-Redisson配置基礎(chǔ)上我們進(jìn)行了改造,讓鎖的使用更加方便

基礎(chǔ)設(shè)施

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; //加鎖的時(shí)間默認(rèn)3秒,  如果任務(wù)在3秒內(nèi)執(zhí)行完畢那么自動(dòng)釋放鎖,如果任務(wù)3秒內(nèi)沒有執(zhí)行完畢也會(huì)釋放鎖, 所以內(nèi)容執(zhí)行時(shí)間過長(zhǎng)適當(dāng)加大鎖的時(shí)間
    String key() default "" ;  //唯一標(biāo)識(shí),如果沒有那么默認(rèn)為token->sessionId
    String doc() default "重復(fù)提交請(qǐng)求,請(qǐng)稍后再試";
    boolean repeatLock() default false; //可重復(fù)加鎖直到加鎖成功,默認(rèn)為false不能重復(fù)加鎖
    int repeatLockCount() default -1; //可重復(fù)加鎖限制加鎖的次數(shù), 默認(rèn)-1直到成功,設(shè)置10那么加鎖10次都沒成功就直接返回
    int lockWaitTimeMs() default 100; //重復(fù)加鎖默認(rèn)的阻塞時(shí)間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 {
                // 執(zhí)行
                result = pjp.proceed();
            } finally {
                // 解鎖
                redisLock.release(key);
            }
            return result;
        } else {
            // 獲取鎖失敗，認(rèn)為是重復(fù)提交的請(qǐng)求
            return Result.Error(doc);
        }
    }
    private String getKey(String token, String path) {
        return token + path;
    }
}

DistributedRedisLock

/**
 * 簡(jiǎn)要描述
 *
 * @Author: huanmin
 * @Date: 2022/8/1 17:39
 * @Version: 1.0
 * @Description: 文件作用詳細(xì)描述....
 */

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對(duì)象
    @Autowired
    private RedissonClient redissonClient;
    private final String LOCK_TITLE = "redisLock_";
    private final ThreadLocal<Integer> count = new ThreadLocal<>();//計(jì)數(shù)

    //加鎖 , 線程加鎖的時(shí)候發(fā)現(xiàn),鎖有人用了 ,那么就會(huì)進(jìn)入自旋等待
    @SneakyThrows
    public boolean acquire(String lockKey, long seconds, boolean repeatLock, int repeatLockCount, int lockWaitTimeMs) {
        count.set(0); //初始化值
        //獲取鎖對(duì)象
        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());
            //獲取加鎖的次數(shù),如果是-1那么持續(xù)加鎖,如果滿足加鎖次數(shù)那么結(jié)束加鎖
            if (repeatLockCount != -1 && count.get().equals(repeatLockCount)) {
                logger.warn(Thread.currentThread().getName() + "嘗試加鎖失敗以嘗試了:" + count.get() + "次");
                return false;
            }
            SleepTools.ms(lockWaitTimeMs);
            //加鎖次數(shù)增加
            count.set(count.get() + 1);
        } while (repeatLock);
        logger.warn("重復(fù)提交");
        return false;
    }

    //手動(dòng)鎖的釋放
    public void release(String lockKey) {
        //獲取所對(duì)象
        RLock mylock = redissonClient.getLock((LOCK_TITLE + lockKey));
        // 這里判斷下當(dāng)前key是否上鎖，不然業(yè)務(wù)執(zhí)行時(shí)間大于鎖自動(dòng)釋放時(shí)間后，解鎖報(bào)異常
        if (mylock.isLocked()&&mylock.isHeldByCurrentThread()) { // 是否還是鎖定狀態(tài)并且鎖是當(dāng)前線程的
                mylock.unlock(); // 釋放鎖
                logger.info("解鎖:" + lockKey);
        }

    }
}

功能使用和介紹

• 支持配置鎖的時(shí)間

• 支持配置鎖的key(同一個(gè)key的請(qǐng)求會(huì)被鎖住)

• 支持重復(fù)加鎖

• 支持重復(fù)加鎖的次數(shù)

• 支持重復(fù)加鎖的間隔時(shí)間

通過以上功能的的組合能做到,冪等性,分布式悲觀鎖, 超時(shí)丟棄 ,不止在Controller里使用,而是在任何基于Spring容器管理的Bean都支持,當(dāng)然如果特殊的場(chǎng)景我們可以直接使用DistributedRedisLock類,注意在任何時(shí)候都要釋放鎖

    /***
     *默認(rèn)加鎖3秒
     * 加鎖的key為token->sessionId
     * 加鎖失敗不可重復(fù)加鎖
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock
    @GetMapping(value = "/updateAgeAsyncLock" )
    public Result updateAgeAsyncLock() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }

    /***
     * 默認(rèn)加鎖3秒
     * 加鎖失敗不可重復(fù)加鎖
     * 加鎖的key為token->sessionId
     * 提示:  加鎖失敗
     */
    @RedissonLock(doc = "加鎖失敗")
    @GetMapping(value = "/updateAgeAsyncLockDoc" )
    public Result updateAgeAsyncLockDoc() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }
    /***
     * 默認(rèn)加鎖15秒
     * 加鎖失敗不可重復(fù)加鎖
     * 加鎖的key為token->sessionId
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock(lockTime = 15)
    @GetMapping(value = "/updateAgeAsyncLock0" )
    public Result updateAgeAsyncLock0() {
         userService.updateAgeAsyncLock();
         return Result.Ok();
    }

    /***
     * 默認(rèn)加鎖15秒
     * 加鎖失敗不可重復(fù)加鎖
     * 加鎖的key為updateAgeAsyncLock
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock(lockTime = 15,key = "updateAgeAsyncLock")
    @GetMapping(value = "/updateAgeAsyncLock1" )
    public Result updateAgeAsyncLock1() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }
    /***
     * 默認(rèn)加鎖15秒
     * 加鎖失敗可重復(fù)加鎖,直到加鎖成功
     * 加鎖的key為updateAgeAsyncLock
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true)
    @GetMapping(value = "/updateAgeAsyncLock2" )
    public Result updateAgeAsyncLock2() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }

    /***
     * 默認(rèn)加鎖15秒
     * 加鎖失敗可重復(fù)加鎖10次,每次默認(rèn)間隔100毫秒
     * 加鎖的key為updateAgeAsyncLock
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true,repeatLockCount = 10)
    @GetMapping(value = "/updateAgeAsyncLock3" )
    public Result updateAgeAsyncLock3() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }
    /***
     * 默認(rèn)加鎖15秒
     * 加鎖失敗可重復(fù)加鎖10次,每次默認(rèn)間隔500毫秒
     * 加鎖的key為updateAgeAsyncLock
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true,repeatLockCount = 10,lockWaitTimeMs = 500)
    @GetMapping(value = "/updateAgeAsyncLock4" )
    public Result updateAgeAsyncLock4() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }
    /***
     * 默認(rèn)加鎖15秒
     * 加鎖失敗可重復(fù)加鎖,直到成功,每次嘗試間隔500毫秒
     * 加鎖的key為updateAgeAsyncLock
     * 默認(rèn)提示:  重復(fù)提交請(qǐng)求,請(qǐng)稍后再試
     */
    @RedissonLock(lockTime = 15,key = "updateAgeAsyncLock",repeatLock = true,lockWaitTimeMs = 500)
    @GetMapping(value = "/updateAgeAsyncLock4" )
    public Result updateAgeAsyncLock4() {
        userService.updateAgeAsyncLock();
        return Result.Ok();
    }

驗(yàn)證方式: 使用jmeter多線程10000請(qǐng)求 ,注意使用jmeter的時(shí)候不要使用默認(rèn)鎖key的方式,因?yàn)閖meter每次請(qǐng)sessionID都不同的,想要驗(yàn)證效果我們需要手動(dòng)加key或者使用token

其他悲觀鎖的實(shí)現(xiàn)方式

public class DistributedRedisLock {
    //從配置類中獲取redisson對(duì)象
    @Autowired
    private RedissonClient redissonClient;
    private  final String LOCK_TITLE = "redisLock_";
    //加鎖 , 線程加鎖的時(shí)候發(fā)現(xiàn),鎖有人用了 ,那么就會(huì)進(jìn)入自旋等待
    public  boolean acquire(String lockName){
        //聲明key對(duì)象
        String key = LOCK_TITLE + lockName;

        //獲取鎖對(duì)象
        RLock mylock = redissonClient.getLock(key);
        //一直等待直到加鎖成功后，并且設(shè)置鎖過期時(shí)間，防止死鎖的產(chǎn)生
        mylock.lock(10, TimeUnit.SECONDS);
        System.err.println("======lock======"+Thread.currentThread().getName());
        //加鎖成功
        return  true;
    }
    //鎖的釋放
    public    void release(String lockName){
        //必須是和加鎖時(shí)的同一個(gè)key
        String key = LOCK_TITLE + lockName;
        //獲取所對(duì)象
        RLock mylock = redissonClient.getLock(key);
     // 這里判斷下當(dāng)前key是否上鎖，不然業(yè)務(wù)執(zhí)行時(shí)間大于鎖自動(dòng)釋放時(shí)間后，解鎖報(bào)異常
        if(mylock.isLocked()){ // 是否還是鎖定狀態(tài)
            if(mylock.isHeldByCurrentThread()){ // 時(shí)候是當(dāng)前執(zhí)行線程的鎖
                mylock.unlock(); // 釋放鎖
                System.err.println("======unlock======"+Thread.currentThread().getName());
            }
        }
    }
}

以上就是“Java-Redis-Redisson分布式鎖的功能如何使用及實(shí)現(xiàn)”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會(huì)為大家更新不同的知識(shí)，如果還想學(xué)習(xí)更多的知識(shí)，請(qǐng)關(guān)注億速云行業(yè)資訊頻道。