歡迎光臨
每天分享高質量文章

實踐基於Redis的分佈式鎖

本文來自社區這周的討論話題—— 技術專題討論第四期:漫談分佈式鎖,也總結了我對分佈式鎖的認知和使用經驗。

應用場景

當多個機器(多個行程)會對同一條資料進行修改時,並且要求這個修改是原子性的。這裡有兩個限定:(1)多個行程之間的競爭,意味著JDK自帶的鎖失效;(2)原子性修改,意味著資料是有狀態的,修改前後有依賴。

實現方式

  • 基於Redis實現,主要基於redis的setnx(set if not exist)命令;

  • 基於Zookeeper實現;

  • 基於version欄位實現,樂觀鎖,兩個執行緒可以同時讀取到原有的version值,但是最終只有一個可以完成操作;

這三種方式中,我接觸過第一和第三種。基於redis的分佈式鎖功能更加強大,可以實現阻塞和非阻塞鎖。

基於Redis的實踐

鎖的實現

  • 鎖的key為標的資料的唯一鍵,value為鎖的期望超時時間點;

  • 首先進行一次setnx命令,嘗試獲取鎖,如果獲取成功,則設置鎖的最終超時時間(以防在當前行程獲取鎖後奔潰導致鎖無法釋放);如果獲取鎖失敗,則檢查當前的鎖是否超時,如果發現沒有超時,則獲取鎖失敗;如果發現鎖已經超時(即鎖的超時時間小於等於當前時間),則再次嘗試獲取鎖,取到後判斷下當前的超時時間和之前的超時時間是否相等,如果相等則說明當前的客戶端是排隊等待的執行緒里的第一個嘗試獲取鎖的,讓它獲取成功即可。 

  1. public class RedisDistributionLock {

  2.    private static final Logger logger = LoggerFactory.getLogger(RedisDistributionLock.class);

  3.    //key的TTL,一天

  4.    private static final int finalDefaultTTLwithKey = 24 * 3600;

  5.    //鎖預設超時時間,20秒

  6.    private static final long defaultExpireTime = 20 * 1000;

  7.    private static final boolean Success = true;

  8.    @Resource( name = "redisTemplate")

  9.    private RedisTemplate<String, String> redisTemplateForGeneralize;

  10.    /**

  11.     * 加鎖,鎖預設超時時間20秒

  12.     * @param resource

  13.     * @return

  14.     */

  15.    public boolean lock(String resource) {

  16.        return this.lock(resource, defaultExpireTime);

  17.    }

  18.    /**

  19.     * 加鎖,同時設置鎖超時時間

  20.     * @param key 分佈式鎖的key

  21.     * @param expireTime 單位是ms

  22.     * @return

  23.     */

  24.    public boolean lock(String key, long expireTime) {

  25.        logger.debug("redis lock debug, start. key:[{}], expireTime:[{}]",key,expireTime);

  26.        long now = Instant.now().toEpochMilli();

  27.        long lockExpireTime = now + expireTime;

  28.        //setnx

  29.        boolean executeResult = redisTemplateForGeneralize.opsForValue().setIfAbsent(key,String.valueOf(lockExpireTime));

  30.        logger.debug("redis lock debug, setnx. key:[{}], expireTime:[{}], executeResult:[{}]", key, expireTime,executeResult);

  31.        //取鎖成功,為key設置expire

  32.        if (executeResult == Success) {

  33.            redisTemplateForGeneralize.expire(key,finalDefaultTTLwithKey, TimeUnit.SECONDS);

  34.            return true;

  35.        }

  36.        //沒有取到鎖,繼續流程

  37.        else{

  38.            Object valueFromRedis = this.getKeyWithRetry(key, 3);

  39.            // 避免獲取鎖失敗,同時對方釋放鎖後,造成NPE

  40.            if (valueFromRedis != null) {

  41.                //已存在的鎖超時時間

  42.                long oldExpireTime = Long.parseLong((String)valueFromRedis);

  43.                logger.debug("redis lock debug, key already seted. key:[{}], oldExpireTime:[{}]",key,oldExpireTime);

  44.                //鎖過期時間小於當前時間,鎖已經超時,重新取鎖

  45.                if (oldExpireTime <= now) {

  46.                    logger.debug("redis lock debug, lock time expired. key:[{}], oldExpireTime:[{}], now:[{}]", key, oldExpireTime, now);

  47.                    String valueFromRedis2 = redisTemplateForGeneralize.opsForValue().getAndSet(key, String.valueOf(lockExpireTime));

  48.                    long currentExpireTime = Long.parseLong(valueFromRedis2);

  49.                    //判斷currentExpireTime與oldExpireTime是否相等

  50.                    if(currentExpireTime == oldExpireTime){

  51.                        //相等,則取鎖成功

  52.                        logger.debug("redis lock debug, getSet. key:[{}], currentExpireTime:[{}], oldExpireTime:[{}], lockExpireTime:[{}]", key, currentExpireTime, oldExpireTime, lockExpireTime);

  53.                        redisTemplateForGeneralize.expire(key, finalDefaultTTLwithKey, TimeUnit.SECONDS);

  54.                        return true;

  55.                    }else{

  56.                        //不相等,取鎖失敗

  57.                        return false;

  58.                    }

  59.                }

  60.            }

  61.            else {

  62.                logger.warn("redis lock,lock have been release. key:[{}]", key);

  63.                return false;

  64.            }

  65.        }

  66.        return false;

  67.    }

  68.    private Object getKeyWithRetry(String key, int retryTimes) {

  69.        int failTime = 0;

  70.        while (failTime < retryTimes) {

  71.            try {

  72.                return redisTemplateForGeneralize.opsForValue().get(key);

  73.            } catch (Exception e) {

  74.                failTime++;

  75.                if (failTime >= retryTimes) {

  76.                    throw e;

  77.                }

  78.            }

  79.        }

  80.        return null;

  81.    }

  82.    /**

  83.     * 解鎖

  84.     * @param key

  85.     * @return

  86.     */

  87.    public boolean unlock(String key) {

  88.        logger.debug("redis unlock debug, start. resource:[{}].",key);

  89.        redisTemplateForGeneralize.delete(key);

  90.        return Success;

  91.    }

  92. }

自定義註解使用分佈式鎖

  1. @Retention(RetentionPolicy.RUNTIME)

  2. @Target(ElementType.METHOD)

  3. public @interface RedisLockAnnoation {

  4.    String keyPrefix() default "";

  5.    /**

  6.     * 要鎖定的key中包含的屬性

  7.     */

  8.    String[] keys() default {};

  9.    /**

  10.     * 是否阻塞鎖;

  11.     * 1. true:獲取不到鎖,阻塞一定時間;

  12.     * 2. false:獲取不到鎖,立即傳回

  13.     */

  14.    boolean isSpin() default true;

  15.    /**

  16.     * 超時時間

  17.     */

  18.    int expireTime() default 10000;

  19.    /**

  20.     * 等待時間

  21.     */

  22.    int waitTime() default 50;

  23.    /**

  24.     * 獲取不到鎖的等待時間

  25.     */

  26.    int retryTimes() default 20;

  27. }

實現分佈式鎖的邏輯

  1. @Component

  2. @Aspect

  3. public class RedisLockAdvice {

  4.    private static final Logger logger = LoggerFactory.getLogger(RedisLockAdvice.class);

  5.    @Resource

  6.    private RedisDistributionLock redisDistributionLock;

  7.    @Around("@annotation(RedisLockAnnoation)")

  8.    public Object processAround(ProceedingJoinPoint pjp) throws Throwable {

  9.        //獲取方法上的註解物件

  10.        String methodName = pjp.getSignature().getName();

  11.        Class> classTarget = pjp.getTarget().getClass();

  12.        Class>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();

  13.        Method objMethod = classTarget.getMethod(methodName, par);

  14.        RedisLockAnnoation redisLockAnnoation = objMethod.getDeclaredAnnotation(RedisLockAnnoation.class);

  15.        //拼裝分佈式鎖的key

  16.        String[] keys = redisLockAnnoation.keys();

  17.        Object[] args = pjp.getArgs();

  18.        Object arg = args[0];

  19.        StringBuilder temp = new StringBuilder();

  20.        temp.append(redisLockAnnoation.keyPrefix());

  21.        for (String key : keys) {

  22.            String getMethod = "get" + StringUtils.capitalize(key);

  23.            temp.append(MethodUtils.invokeExactMethod(arg, getMethod)).append("_");

  24.        }

  25.        String redisKey = StringUtils.removeEnd(temp.toString(), "_");

  26.        //執行分佈式鎖的邏輯

  27.        if (redisLockAnnoation.isSpin()) {

  28.            //阻塞鎖

  29.            int lockRetryTime = 0;

  30.            try {

  31.                while (!redisDistributionLock.lock(redisKey, redisLockAnnoation.expireTime())) {

  32.                    if (lockRetryTime++ > redisLockAnnoation.retryTimes()) {

  33.                        logger.error("lock exception. key:{}, lockRetryTime:{}", redisKey, lockRetryTime);

  34.                        throw ExceptionUtil.geneException(CommonExceptionEnum.SYSTEM_ERROR);

  35.                    }

  36.                    ThreadUtil.holdXms(redisLockAnnoation.waitTime());

  37.                }

  38.                return pjp.proceed();

  39.            } finally {

  40.                redisDistributionLock.unlock(redisKey);

  41.            }

  42.        } else {

  43.            //非阻塞鎖

  44.            try {

  45.                if (!redisDistributionLock.lock(redisKey)) {

  46.                    logger.error("lock exception. key:{}", redisKey);

  47.                    throw ExceptionUtil.geneException(CommonExceptionEnum.SYSTEM_ERROR);

  48.                }

  49.                return pjp.proceed();

  50.            } finally {

  51.                redisDistributionLock.unlock(redisKey);

  52.            }

  53.        }

  54.    }

  55. }

參考資料

  1. Java分佈式鎖三種實現方案

  2. Java註解的基礎與高級應用

  3. 基於 AOP 和 Redis 實現的分佈式鎖

  4. 如何高效排查系統故障?一分錢引發的系統設計“踩坑”案例

  5. 用redis實現分佈式鎖

赞(0)

分享創造快樂

© 2022 知識星球   网站地图